EVGD: Códigos Toscos

Assuntos Gerais
#667

Ele tem alguma justificativa boa pra pensar assim ??? quer dizer… alguém tem ???

Falows :wink:

#668

[quote=luistiagos]quem não lembra da velha gambi para fazer muitas vezes sqls dinamicos?

where 1 = 1 [/quote]

kkkkkkkkkkkkkkkkkk
[size=18]Crássica![/size]

Já vi situações que esse POO (Programação orientada à oreagem) era motivo de travamento no banco Pervasive!
Sinistro!

#669

Um pedaço da classe Utils de um sistema da empresa na qual trabalho:

[code]public static String br(boolean pRetornoCarro) {
return !pRetornoCarro ? “” + (char) 13 : “” + (char) 13 + (char) 10;
}

/**
* retorna uma table de altura 3 para dar um espacamento no html
* (substitui BR)
*/
public static String espacoHTML() {
return “

” + br() + " " + br() + " " + br() + " " + br() + "
" + br() + "
" + br();
}

/**
* retorna uma table de altura pHeight, para dar um espacamento no html
* (substitui BR)
*/
public static String espacoHTML(int pHeight) {
return “

” + br() + " " + br() + " " + br() + " " + br() + "
" + br() + "
" + br();
}

public static String maxString(int pLength, String pString, boolean pComPontinhos) {
if (stringVazia(pString)) {
return “”;
}
if (pString.length() > pLength) {
return pComPontinhos ? pString.substring(0, pLength - 3) + “…” : pString.substring(0, pLength);
}
return pString;
}

public static int novoCodigo(int pCodAtual) {
return pCodAtual + 1;
}

/**

  • Aplica o Plural
    */
    public static String plural(String texto) {
    if (stringVazia(texto)) {
    return “”;
    }
if (testaFinalString(texto, "ao")) {
  return texto.substring(0, texto.length() - 2) + "oes";
}
if (testaFinalString(texto, "is") || testaFinalString(texto, "or") || testaFinalString(texto, "ar")) {
  return texto + "es";
}
if (testaFinalString(texto, "l")) {
  return texto.substring(0, texto.length() - 1) + "ies";
}
if (testaFinalString(texto, "ly")) {
  return texto.substring(0, texto.length() - 2) + "ies";
}

return texto + "s";

}
/**

  • Método que converte uma String no padrão #,##0.00 para um double
    */
    public static double stringToDouble(String pString) {
    if (stringVazia(pString)) {
    return Double.NEGATIVE_INFINITY;
    }
String aux = pString;
String[] vecPonto = stringToArray(pString, ".", true);
String[] vecVirgula = stringToArray(pString, ",", true);

if (vecVirgula.length > 1 && vecPonto.length > 1) {
  if (vecVirgula.length == vecPonto.length) {
    if (vecVirgula[0].length() < vecPonto[0].length()) {
      aux = trocaSubString(aux, ",", "");
    } else {
      aux = trocaSubString(aux, ".", "");
      aux = trocaSubString(aux, ",", ".");
    }
  } else if (vecVirgula.length > vecPonto.length) {
    aux = trocaSubString(aux, ",", "");
  } else {
    aux = trocaSubString(aux, ".", "");
    aux = trocaSubString(aux, ",", ".");
  }
} else if (vecVirgula.length > 2 || vecPonto.length > 2) {
  aux = trocaSubString(aux, ".", "");
  aux = trocaSubString(aux, ",", "");
} else if (vecVirgula.length == 2) {
  aux = trocaSubString(aux, ",", ".");
}

return (new Double(aux)).doubleValue();

}

/**

  • testa se a string termina em XXXXX
    */
    public static boolean testaFinalString(String texto, String teste) {
    if (stringVazia(texto) || stringVazia(teste) || teste.length() > texto.length()) {
    return false;
    }
    return texto.substring(texto.length() - teste.length()).equals(teste);
    }

/**

  • testa se a string inicia em XXXXX
    */
    public static boolean testaInicioString(String texto, String teste) {
    if (stringVazia(texto) || stringVazia(teste) || teste.length() > texto.length()) {
    return false;
    }
    return texto.substring(0, teste.length()).equals(teste);
    }[/code]
#670

WTF !!!

aplica o plural :lol: :lol: :lol: :lol: :lol:

Onde é utilizado aquilo?

#671

Pior são esses testaFinalString e testaInicioString.
Para que usar o startsWith e endsWith de String, né?

Era bom colocar, além da pérola, o jeito certo de fazer.
Para comparar o número de linhas (geralmente bem menor), para ensinamento e pelos novos códigos toscos que isso pode gerar :mrgreen:

#672

[quote=Jose111]WTF !!!

aplica o plural :lol: :lol: :lol: :lol: :lol:

Onde é utilizado aquilo?[/quote]

Provavelmente algum tipo de correção ortográfica. Estou fazendo um em português e ao menos as regras de português são muuuuuuuuuito mais complexas que esse método.

#673

O Rails usa algo assim, não?
Ao criar uma entidade Story, ele cria a tabela Stories no banco.

O Netbeans também tinha algo assim no editor de código, acho que era no template de foreach.

#674

aplica o plural

essa eu to curioso.

#675

Num certo enum…

[code]
public static TipoPessoa valueOf(int codigo) {
TipoPessoa valor = null;
for (TipoPessoa elemento : values()) {
if (elemento.getCodigo() == codigo) {
valor = elemento;
break;
}
}
if (valor == null) {
throw new IllegalArgumentException("Código inválido: " + codigo);
}

return valor;

}[/code]

Melhor seria:

[code]
public static TipoPessoa valueOf(int codigo) {
for (TipoPessoa elemento : values())
if (TipoPessoa elemento.getCodigo() == codigo)
return elemento;

throw new IllegalArgumentException("Código inválido: " + codigo);

}[/code]

#676

[quote=Jose111]WTF !!!

aplica o plural :lol: :lol: :lol: :lol: :lol:

Onde é utilizado aquilo?[/quote]

Já precisei criar um código pra aplicar plural, num gerador de código.

#677

[quote=Bruno Laturner][quote=arthurminarini]conheço um programador que gosta de nomes bem intuitivos. É SERIO MESMO NÃO É ZUAÇÃO

if (loginBlz) { blzPodePassar = true; sairAtualizandoMensagemQueFoiMostradaAUmTempoAtras(); } [/quote]

Corrigido:

if (loginBlz) { blzPodePassar = true; sairAtualizandoMensagemQueFoiMostradaHaUmTempoAtras(); } [/quote]

Na verdade, o erro apenas piorou. ‘há’ um tempo ‘atrás’ é pleonasmo.

O correto seria:

sairAtualizandoMensagemQueFoiMostradaHaUmTempo();

Ou

sairAtualizandoMensagemQueFoiMostradaUmTempoAtras();
#678

[quote=luistiagos]quem não lembra da velha gambi para fazer muitas vezes sqls dinamicos?

where 1 = 1 [/quote]

Não consideraria isso uma gambiarra. É apenas um meio de tornar um código menos condicional. Agrega-se a isso o fato de ‘1 = 1’ ser uma expressão que os SGDB’s normalmente já são capazes de desconsiderar e, ainda que ‘resolvam’ a condição, o envolvimento na operação seja totalmente ignorável.

No caso de um SQL dinâmico (independente à existência de Hibernate ou de quaisquer frameworks e afins), como seria o correto*?

*sendo, para fins de explicação, ‘correto’ o antônimo de ‘gambiarra’

#679

[quote=Yky Mattshawn][quote=luistiagos]quem não lembra da velha gambi para fazer muitas vezes sqls dinamicos?

where 1 = 1 [/quote]

Não consideraria isso uma gambiarra. É apenas um meio de tornar um código menos condicional. Agrega-se a isso o fato de ‘1 = 1’ ser uma expressão que os SGDB’s normalmente já são capazes de desconsiderar e, ainda que ‘resolvam’ a condição, o envolvimento na operação seja totalmente ignorável.

No caso de um SQL dinâmico (independente à existência de Hibernate ou de quaisquer frameworks e afins), como seria o correto*?

*sendo, para fins de explicação, ‘correto’ o antônimo de ‘gambiarra’[/quote]

É estranho… pq 1 sera sempre = 1…

#680

[quote=luistiagos]
É estranho… pq 1 sera sempre = 1… [/quote]

Mas tu mesmo disseste:

para fazer muitas vezes sqls dinamicos

A questão não é o resultado de 1 = 1, mas por que ele está sendo utilizado.

Sempre vi esse tipo de SQL em códigos que geravam instruções SQL dinâmicas. Suponha que tu tenhas um SELECT básico com vários filtros OPCIONAIS.

SELECT tabela.ID FROM tabela

Filtros: CampoA e CampoB. Um ou outro dos campos pode ser filtrado, mas nenhum é obrigatório, bem como não são dependentes entre si. Sem o uso do 1 = 1, preciso condicionar bem mais o código, ficando assim em exemplo (em JS pra simplificar):

var sql = "SELECT tabela.ID FROM tabela";
var existeWhere = false;

if (campoA.value != "")
  {
   if (!existeWhere)
     {
      existeWhere = true;
      sql += " WHERE";
     }
   else
      { sql += " AND"; }

   sql += "tabela.CampoA = " + campoA.value;
  }

if (campoB.value != "")
  {
   if (!existeWhere)
     {
      existeWhere = true;
      sql += " WHERE";
     }
   else
      { sql += " AND"; }

   sql += "tabela.CampoB = " + campoB.value;
  }

Perceba, acima, que é necessário que os códigos subsequentes ‘conheçam’ a existência do WHERE na instrução.

Mas veja como ficaria simples se eu usasse o 1 = 1:

var sql = "SELECT tabela.ID FROM tabela WHERE 1 = 1";

if (campoA.value != "")
  { sql += " AND tabela.CampoA = " + campoA.value; }

if (campoB.value != "")
  { sql += " AND tabela.CampoB = " + campoB.value; }

Concluindo: a expressão 1 = 1 existe só e somente só nestas especificidades de alguma necessidade de otimização (lê-se isso como ‘subtração’) de linhas de código.

#681

[quote=luistiagos][quote=Yky Mattshawn][quote=luistiagos]quem não lembra da velha gambi para fazer muitas vezes sqls dinamicos?

where 1 = 1 [/quote]

Não consideraria isso uma gambiarra. É apenas um meio de tornar um código menos condicional. Agrega-se a isso o fato de ‘1 = 1’ ser uma expressão que os SGDB’s normalmente já são capazes de desconsiderar e, ainda que ‘resolvam’ a condição, o envolvimento na operação seja totalmente ignorável.

No caso de um SQL dinâmico (independente à existência de Hibernate ou de quaisquer frameworks e afins), como seria o correto*?

*sendo, para fins de explicação, ‘correto’ o antônimo de ‘gambiarra’[/quote]

É estranho… pq 1 sera sempre = 1… [/quote]

Lógica booleana no SQL é estranha mesmo.

Um AND x = 1 AND x = 2 vai trazer valores onde x é 1 ou 2.

#682

[quote=Bruno Laturner][quote=luistiagos][quote=Yky Mattshawn][quote=luistiagos]quem não lembra da velha gambi para fazer muitas vezes sqls dinamicos?

where 1 = 1 [/quote]

Não consideraria isso uma gambiarra. É apenas um meio de tornar um código menos condicional. Agrega-se a isso o fato de ‘1 = 1’ ser uma expressão que os SGDB’s normalmente já são capazes de desconsiderar e, ainda que ‘resolvam’ a condição, o envolvimento na operação seja totalmente ignorável.

No caso de um SQL dinâmico (independente à existência de Hibernate ou de quaisquer frameworks e afins), como seria o correto*?

*sendo, para fins de explicação, ‘correto’ o antônimo de ‘gambiarra’[/quote]

É estranho… pq 1 sera sempre = 1… [/quote]

Lógica booleana no SQL é estranha mesmo.

Um AND x = 1 AND x = 2 vai trazer valores onde x é 1 ou 2.

[/quote]

Mas qual o torpe SGDB que tens usado?

Ao menos no MySQL isso não funciona assim não…

Aliás, se testares alguma instrução do tipo que citaste com o ‘EXPLAIN’ no início, o MySQL será enfático ao declarar:

Impossible WHERE

P.S.: não considero a lógica booleana no SQL muito diferente da existente nas linguagens de programação. O SQL, às vezes, pode exigir mais atenção quanto à procedência de parêntesis, uma vez que toda a lógica se faz numa única linha (saldo SPs e FNCs), mas nada que torne essa lógica estranha.

#683

Estranho, fiz no Oracle, tentei com uma consulta simples e realmente não deu certo.

Falei o que disse acima baseado numa consulta meio complicada. Agora tenho que achar ela de novo pra confirmar.

#684

[quote=Yky Mattshawn]
Concluindo: a expressão 1 = 1 existe só e somente só nestas especificidades de alguma necessidade de otimização (lê-se isso como ‘subtração’) de linhas de código.[/quote]

Ou, só existe qndo não se usa um Hibernate Criteria(ou qq outro tipo de abstração do SQL) =)

#685

[quote=clone_zealot][quote=Yky Mattshawn]
Concluindo: a expressão 1 = 1 existe só e somente só nestas especificidades de alguma necessidade de otimização (lê-se isso como ‘subtração’) de linhas de código.[/quote]

Ou, só existe qndo não se usa um Hibernate Criteria(ou qq outro tipo de abstração do SQL) =)[/quote]

Somente na abstração da suposta comodidade de uma API gigante…

Veja o que podemos encontrar nos códigos do Hibernate:

core\src\main\java\org\hibernate\criterion\Junction.java(76): if ( criteria.size()==0 ) return "1=1";
core\src\main\java\org\hibernate\criterion\Example.java(238): if ( buf.length()==1 ) buf.append("1=1"); //yuck!
testsuite\src\test\java\org\hibernate\test\component\basic\ComponentTest.java(159): s.createQuery( "from Employee e where e.person = :p and 1 = 1 and 2=2" ).setParameter( "p", emp.getPerson() ).list();

testsuite\src\test\java\org\hibernate\test\hql\HqlParserTest.java(392): parse( "select foo.foo.foo.foo from foo in class org.hibernate.test.Foo, foo2 in class org.hibernate.test.Foo where foo = foo2.foo and not not ( not foo.string='fizard' ) and foo2.string between 'a' and (foo.foo.string) and ( foo2.string in ( 'fiz', 'blah') or 1=1 )" );

testsuite\src\test\java\org\hibernate\test\hql\HqlParserTest.java(784): parse( "from c in class org.hibernate.test.C2 where 1=1 or 1=1" );

testsuite\src\test\java\org\hibernate\test\legacy\ABCTest.java(78): assertTrue( s.find("from C2 c where 1=1 or 1=1").size()==0 );

testsuite\src\test\java\org\hibernate\test\legacy\FooBarTest.java(523): " and ( foo2.string in ( 'fiz', 'blah') or 1=1 )"

Pelo visto, tem mais gente que usa esse ‘auxílio’… até o pessoal abstrato, digo, o pessoal responsável pela abstração do Hibernate… :wink:

OBS: aquela comentário ‘yuck’ está mesmo no source do Hibernate.

#686

[quote=clone_zealot][quote=Yky Mattshawn]
Concluindo: a expressão 1 = 1 existe só e somente só nestas especificidades de alguma necessidade de otimização (lê-se isso como ‘subtração’) de linhas de código.[/quote]

Ou, só existe qndo não se usa um Hibernate Criteria(ou qq outro tipo de abstração do SQL) =)[/quote]

Não existe não… vc não ve… ou vc sabe exatamente a query que o Criteria gera por traz?
ja vi o hql gerando muita query bizzara… :shock: por isto não gosto muito do hql e nem Criteria…
depende muito do que vai fazer… se for algo simples dai blza… mas se for algo complexo ele pode gerar uma bizzarisse com a query do sql nativo…