Poprawny sposób użycia StringBuilder w SQL

Jeśli masz już wszystkie "kawałki", które chcesz dołączyć, nie ma sensu używać StringBuilder w ogóle. Za pomocą StringBuilder i konkatenacja ciągu w tym samym wywołaniu, jak na przykładowym kodzie jest jeszcze gorsza.

Tak byłoby lepiej:

return "select id1, " + " id2 " + " from " + " table";

W tym przypadku konkatenacja łańcuchów rzeczywiście dzieje się w compile-time w każdym razie, więc jest to odpowiednik nawet prostszego:

return "select id1, id2 from table";

Użycie new StringBuilder().append("select id1, ").append(" id2 ")....toString() w rzeczywistości utrudni wydajność w tym przypadku, ponieważ wymusza ona wykonanie konkatenacji w czasie wykonania , zamiast w czasie kompilacji. UPS.

Jeśli prawdziwy kod buduje zapytanie SQL przez włączenie wartości do zapytania, to jest to kolejna oddzielna sprawa , która polega na tym, że powinieneś używać zapytań sparametryzowanych, określając wartości w parametrach, a nie w SQL.

Mam artykuł o String / StringBuffer które napisałem jakiś czas temu-przed StringBuilder przyszedł. Zasady mają zastosowanie do StringBuilder w ten sam sposób.

[[jest kilka dobrych odpowiedzi tutaj, ale uważam, że nadal brakuje im trochę informacji. ]]

return (new StringBuilder("select id1, " + " id2 " + " from " + " table"))
     .toString();

Więc jak zauważyłeś, przykład, który podałeś, jest uproszczony, ale przeanalizujmy go i tak. To, co się tutaj dzieje, to kompilator faktycznie działa +, ponieważ "select id1, " + " id2 " + " from " + " table" są stałymi. Więc to zamienia się w:

return new StringBuilder("select id1,  id2  from  table").toString();

W tym przypadku, oczywiście, nie ma sensu używać StringBuilder. Równie dobrze możesz:

// the compiler combines these constant strings
return "select id1, " + " id2 " + " from " + " table";

Jednakże, nawet jeśli w przypadku dodawania dowolnych pól lub innych nie-stałych kompilator użyłby wewnętrznego StringBuilder -- nie ma potrzeby definiowania jednego:

// an internal StringBuilder is used here
return "select id1, " + fieldName + " from " + tableName;

Pod okładkami, to zamienia się w kod, który jest w przybliżeniu odpowiednikiem:

StringBuilder sb = new StringBuilder("select id1, ");
sb.append(fieldName).append(" from ").append(tableName);
return sb.toString();

Naprawdę jedyny czas, który musisz wykorzystać StringBuilder bezpośrednio jest wtedy, gdy masz kod warunkowy. Na przykład kod, który wygląda jak poniżej, jest rozpaczliwy dla StringBuilder:

// 1 StringBuilder used in this line
String query = "select id1, " + fieldName + " from " + tableName;
if (where != null) {
   // another StringBuilder used here
   query += ' ' + where;
}

+ w pierwszej linii używa jedna StringBuilder instancja. Następnie += używa innej instancji StringBuilder. Jest to bardziej efektywne do zrobienia:

// choose a good starting size to lower chances of reallocation
StringBuilder sb = new StringBuilder(64);
sb.append("select id1, ").append(fieldName).append(" from ").append(tableName);
// conditional code
if (where != null) {
   sb.append(' ').append(where);
}
return sb.toString();

Innym razem, kiedy używam {[12] } jest budowanie ciągu znaków z wielu wywołań metod. Następnie mogę tworzyć metody, które przyjmują StringBuilder argument:

private void addWhere(StringBuilder sb) {
   if (where != null) {
      sb.append(' ').append(where);
   }
}

Kiedy używasz StringBuilder, powinieneś uważać na jakiekolwiek użycie + w tym samym czasie:

sb.append("select " + fieldName);

To + spowoduje powstanie kolejnego wewnętrznego StringBuilder. Powinno to oczywiście be:

sb.append("select ").append(fieldName);

Na koniec, jak zauważa @T. J. rowder, zawsze powinieneś zgadywać rozmiar StringBuilder. Spowoduje to zapisanie liczby char[] obiektów utworzonych podczas zwiększania rozmiaru wewnętrznego bufora.

Masz rację, zgadując, że cel użycia string builder nie został osiągnięty, przynajmniej nie w pełnym zakresie.

Jednakże, gdy kompilator widzi wyrażenie "select id1, " + " id2 " + " from " + " table" emituje kod, który faktycznie tworzy StringBuilder Za kulisami i dołącza do niego, więc efekt końcowy nie jest taki zły.

Ale oczywiście każdy, kto spojrzy na ten kod, pomyśli, że jest trochę opóźniony.

W kodzie, który napisałeś, nie byłoby żadnych korzyści, ponieważ nadużywasz Stringbuildera. W obu przypadkach tworzysz ten sam ciąg znaków. Używając StringBuilder możesz uniknąć operacji + na łańcuchach używając metody append. Należy go używać w ten sposób:

return new StringBuilder("select id1, ").append(" id2 ").append(" from ").append(" table").toString();

W języku Java typ String jest niezniszczalną sekwencją znaków, więc gdy dodasz dwa ciągi znaków, maszyna wirtualna utworzy nową wartość łańcucha z połączonymi obydwoma operandami.

StringBuilder zapewnia zmienną sekwencję znaki, których można użyć do łączenia różnych wartości lub zmiennych bez tworzenia nowych obiektów łańcuchowych, a więc czasami może być bardziej wydajny niż praca z łańcuchami

Zapewnia to kilka przydatnych funkcji, takich jak zmiana zawartości sekwencji znaków przekazywanej jako parametr w innej metodzie, czego nie można zrobić z łańcuchami znaków.

private void addWhereClause(StringBuilder sql, String column, String value) {
   //WARNING: only as an example, never append directly a value to a SQL String, or you'll be exposed to SQL Injection
   sql.append(" where ").append(column).append(" = ").append(value);
}

Więcej informacji na http://docs.oracle.com/javase/tutorial/java/data/buffers.html

Możesz również użyć MessageFormat również