svn commit: r1839288 [14/20] - in /db/torque/torque4/trunk: torque-ant-tasks/src/main/java/org/apache/torque/ant/task/ torque-generator/src/main/java/org/apache/torque/generator/configuration/ torque-generator/src/main/java/org/apache/torque/generator/...

classic Classic list List threaded Threaded
1 message Options
tv
Reply | Threaded
Open this post in threaded view
|

svn commit: r1839288 [14/20] - in /db/torque/torque4/trunk: torque-ant-tasks/src/main/java/org/apache/torque/ant/task/ torque-generator/src/main/java/org/apache/torque/generator/configuration/ torque-generator/src/main/java/org/apache/torque/generator/...

tv
Modified: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/sql/SqlBuilderTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/sql/SqlBuilderTest.java?rev=1839288&r1=1839287&r2=1839288&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/sql/SqlBuilderTest.java (original)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/sql/SqlBuilderTest.java Mon Aug 27 09:48:33 2018
@@ -61,20 +61,20 @@ public class SqlBuilderTest extends Base
         final String value2a = "2a";
         final String value2b = "2b";
         Criteria c = new Criteria().where(column1, value1a)
-            .and(column1, value1b)
-            .and(column2, value2a)
-            .and(column2, value2b);
+                .and(column1, value1b)
+                .and(column2, value2a)
+                .and(column2, value2b);
 
         Query query = SqlBuilder.buildQuery(c);
 
         assertEquals(
                 "SELECT  FROM myTable "
-                   + "WHERE (myTable.myColumn1=? "
-                   + "AND myTable.myColumn1=? "
-                   + "AND myTable.myColumn2=? "
-                   + "AND myTable.myColumn2=?)",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (myTable.myColumn1=? "
+                        + "AND myTable.myColumn1=? "
+                        + "AND myTable.myColumn2=? "
+                        + "AND myTable.myColumn2=?)",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add(value1a);
         expectedReplacements.add(value1b);
         expectedReplacements.add(value2a);
@@ -96,20 +96,20 @@ public class SqlBuilderTest extends Base
         final String value2a = "2a";
         final String value2b = "2b";
         Criteria c = new Criteria().where(column1, value1a)
-            .or(column1, value1b)
-            .or(column2, value2a)
-            .or(column2, value2b);
+                .or(column1, value1b)
+                .or(column2, value2a)
+                .or(column2, value2b);
 
         Query query = SqlBuilder.buildQuery(c);
 
         assertEquals(
                 "SELECT  FROM myTable "
-                   + "WHERE (myTable.myColumn1=? "
-                   + "OR myTable.myColumn1=? "
-                   + "OR myTable.myColumn2=? "
-                   + "OR myTable.myColumn2=?)",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (myTable.myColumn1=? "
+                        + "OR myTable.myColumn1=? "
+                        + "OR myTable.myColumn2=? "
+                        + "OR myTable.myColumn2=?)",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add(value1a);
         expectedReplacements.add(value1b);
         expectedReplacements.add(value2a);
@@ -139,11 +139,11 @@ public class SqlBuilderTest extends Base
 
         assertEquals(
                 "SELECT  FROM myTable "
-                   + "WHERE (myTable.myColumn1=? "
-                   + "AND myTable.myColumn1=? "
-                   + "AND myTable.myColumn2=?)",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (myTable.myColumn1=? "
+                        + "AND myTable.myColumn1=? "
+                        + "AND myTable.myColumn2=?)",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add(value1a);
         expectedReplacements.add(value1b);
         expectedReplacements.add(value2a);
@@ -172,11 +172,11 @@ public class SqlBuilderTest extends Base
 
         assertEquals(
                 "SELECT  FROM myTable "
-                   + "WHERE (myTable.myColumn1=? "
-                   + "OR myTable.myColumn1=? "
-                   + "OR myTable.myColumn2=?)",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (myTable.myColumn1=? "
+                        + "OR myTable.myColumn1=? "
+                        + "OR myTable.myColumn2=?)",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add(value1a);
         expectedReplacements.add(value1b);
         expectedReplacements.add(value2a);
@@ -191,19 +191,19 @@ public class SqlBuilderTest extends Base
     public void testAndVerbatimSqlReplacementNull() throws Exception
     {
         Criteria criteria = new Criteria()
-            .where(new ColumnImpl("table1.a"), "a")
-            .andVerbatimSql(
-                "foo(table1.x) = bar(table2.y)",
-                null);
+                .where(new ColumnImpl("table1.a"), "a")
+                .andVerbatimSql(
+                        "foo(table1.x) = bar(table2.y)",
+                        null);
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT  FROM table1 "
-                   + "WHERE (table1.a=? "
-                   + "AND foo(table1.x) = bar(table2.y))",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (table1.a=? "
+                        + "AND foo(table1.x) = bar(table2.y))",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add("a");
         assertEquals(
                 expectedReplacements,
@@ -216,19 +216,19 @@ public class SqlBuilderTest extends Base
     public void testAndVerbatimSqlWithReplacements() throws Exception
     {
         Criteria criteria = new Criteria()
-            .where(new ColumnImpl("table1.a"), "a")
-            .andVerbatimSql(
-                "foo(table1.x, ?) = bar(table2.y, ?)",
-                new Object[] {"y", "z"});
+                .where(new ColumnImpl("table1.a"), "a")
+                .andVerbatimSql(
+                        "foo(table1.x, ?) = bar(table2.y, ?)",
+                        new Object[] {"y", "z"});
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT  FROM table1 "
-                   + "WHERE (table1.a=? "
-                   + "AND foo(table1.x, ?) = bar(table2.y, ?))",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (table1.a=? "
+                        + "AND foo(table1.x, ?) = bar(table2.y, ?))",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add("a");
         expectedReplacements.add("y");
         expectedReplacements.add("z");
@@ -243,21 +243,21 @@ public class SqlBuilderTest extends Base
     public void testAndVerbatimSqlWithFromColumns() throws Exception
     {
         Criteria criteria = new Criteria()
-            .where(new ColumnImpl("table1.a"), "a")
-            .andVerbatimSql(
-                "foo(table1.x) = bar(table2.y)",
-                new Object[] {},
-                new ColumnImpl("table1.x"),
-                new ColumnImpl("table2.y"));
+                .where(new ColumnImpl("table1.a"), "a")
+                .andVerbatimSql(
+                        "foo(table1.x) = bar(table2.y)",
+                        new Object[] {},
+                        new ColumnImpl("table1.x"),
+                        new ColumnImpl("table2.y"));
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT  FROM table1, table2 "
-                   + "WHERE (table1.a=? "
-                   + "AND foo(table1.x) = bar(table2.y))",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (table1.a=? "
+                        + "AND foo(table1.x) = bar(table2.y))",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add("a");
         assertEquals(
                 expectedReplacements,
@@ -270,19 +270,19 @@ public class SqlBuilderTest extends Base
     public void testOrVerbatimSqlReplacementNull() throws Exception
     {
         Criteria criteria = new Criteria()
-            .where(new ColumnImpl("table1.a"), "a")
-            .orVerbatimSql(
-                "foo(table1.x) = bar(table2.y)",
-                null);
+                .where(new ColumnImpl("table1.a"), "a")
+                .orVerbatimSql(
+                        "foo(table1.x) = bar(table2.y)",
+                        null);
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT  FROM table1 "
-                   + "WHERE (table1.a=? "
-                   + "OR foo(table1.x) = bar(table2.y))",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (table1.a=? "
+                        + "OR foo(table1.x) = bar(table2.y))",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add("a");
         assertEquals(
                 expectedReplacements,
@@ -295,19 +295,19 @@ public class SqlBuilderTest extends Base
     public void testOrVerbatimSqlWithReplacements() throws Exception
     {
         Criteria criteria = new Criteria()
-            .where(new ColumnImpl("table1.a"), "a")
-            .orVerbatimSql(
-                "foo(table1.x, ?) = bar(table2.y, ?)",
-                new Object[] {"y", "z"});
+                .where(new ColumnImpl("table1.a"), "a")
+                .orVerbatimSql(
+                        "foo(table1.x, ?) = bar(table2.y, ?)",
+                        new Object[] {"y", "z"});
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT  FROM table1 "
-                   + "WHERE (table1.a=? "
-                   + "OR foo(table1.x, ?) = bar(table2.y, ?))",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (table1.a=? "
+                        + "OR foo(table1.x, ?) = bar(table2.y, ?))",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add("a");
         expectedReplacements.add("y");
         expectedReplacements.add("z");
@@ -322,21 +322,21 @@ public class SqlBuilderTest extends Base
     public void testOrVerbatimSqlWithFromColumns() throws Exception
     {
         Criteria criteria = new Criteria()
-            .where(new ColumnImpl("table1.a"), "a")
-            .orVerbatimSql(
-                "foo(table1.x) = bar(table2.y)",
-                new Object[] {},
-                new ColumnImpl("table1.x"),
-                new ColumnImpl("table2.y"));
+                .where(new ColumnImpl("table1.a"), "a")
+                .orVerbatimSql(
+                        "foo(table1.x) = bar(table2.y)",
+                        new Object[] {},
+                        new ColumnImpl("table1.x"),
+                        new ColumnImpl("table2.y"));
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT  FROM table1, table2 "
-                   + "WHERE (table1.a=? "
-                   + "OR foo(table1.x) = bar(table2.y))",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE (table1.a=? "
+                        + "OR foo(table1.x) = bar(table2.y))",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add("a");
         assertEquals(
                 expectedReplacements,
@@ -349,16 +349,16 @@ public class SqlBuilderTest extends Base
     public void testWhereVerbatimSqlReplacementNull() throws Exception
     {
         Criteria criteria = new Criteria()
-            .whereVerbatimSql(
-                "foo(table1.x) = bar(table2.y)",
-                null);
+                .whereVerbatimSql(
+                        "foo(table1.x) = bar(table2.y)",
+                        null);
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT  FROM  "
-                   + "WHERE foo(table1.x) = bar(table2.y)",
-                query.toString());
+                        + "WHERE foo(table1.x) = bar(table2.y)",
+                        query.toString());
         assertEquals(
                 new ArrayList<String>(),
                 query.getPreparedStatementReplacements());
@@ -370,17 +370,17 @@ public class SqlBuilderTest extends Base
     public void testWhereVerbatimSqlWithReplacements() throws Exception
     {
         Criteria criteria = new Criteria()
-            .whereVerbatimSql(
-                "foo(table1.x, ?) = bar(table2.y, ?)",
-                new Object[] {"y", "z"});
+                .whereVerbatimSql(
+                        "foo(table1.x, ?) = bar(table2.y, ?)",
+                        new Object[] {"y", "z"});
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT  FROM  "
-                   + "WHERE foo(table1.x, ?) = bar(table2.y, ?)",
-                query.toString());
-        List<String> expectedReplacements = new ArrayList<String>();
+                        + "WHERE foo(table1.x, ?) = bar(table2.y, ?)",
+                        query.toString());
+        List<String> expectedReplacements = new ArrayList<>();
         expectedReplacements.add("y");
         expectedReplacements.add("z");
         assertEquals(
@@ -394,18 +394,18 @@ public class SqlBuilderTest extends Base
     public void testWhereVerbatimSqlWithFromColumns() throws Exception
     {
         Criteria criteria = new Criteria()
-            .whereVerbatimSql(
-                "foo(table1.x) = bar(table2.y)",
-                new Object[] {},
-                new ColumnImpl("table1.x"),
-                new ColumnImpl("table2.y"));
+                .whereVerbatimSql(
+                        "foo(table1.x) = bar(table2.y)",
+                        new Object[] {},
+                        new ColumnImpl("table1.x"),
+                        new ColumnImpl("table2.y"));
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT  FROM table1, table2 "
-                   + "WHERE foo(table1.x) = bar(table2.y)",
-                query.toString());
+                        + "WHERE foo(table1.x) = bar(table2.y)",
+                        query.toString());
         assertEquals(
                 new ArrayList<String>(),
                 query.getPreparedStatementReplacements());
@@ -424,8 +424,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT unknownTable.column1 FROM unknownTable "
-                   + "WHERE UPPER(column1)=UPPER(?)",
-                query.toString());
+                        + "WHERE UPPER(column1)=UPPER(?)",
+                        query.toString());
     }
 
     public void testIgnoreCaseStringColumnType() throws Exception
@@ -437,8 +437,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN1 FROM TABLE "
-                   + "WHERE UPPER(TABLE.COLUMN1)=UPPER(?)",
-                query.toString());
+                        + "WHERE UPPER(TABLE.COLUMN1)=UPPER(?)",
+                        query.toString());
     }
 
     public void testIgnoreCaseIntegerColumnType() throws Exception
@@ -450,8 +450,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN4 FROM TABLE "
-                   + "WHERE TABLE.COLUMN4=?",
-                query.toString());
+                        + "WHERE TABLE.COLUMN4=?",
+                        query.toString());
     }
 
     public void testOrderByDesc() throws TorqueException
@@ -497,11 +497,11 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT table.column1, table2.column2, table3.column1"
-                    + " FROM table, table2, table3"
-                    + " ORDER BY table.column1 ASC,"
-                    + " table2.column2 DESC,"
-                    + " table3.column1 ASC",
-                query.toString());
+                        + " FROM table, table2, table3"
+                        + " ORDER BY table.column1 ASC,"
+                        + " table2.column2 DESC,"
+                        + " table3.column1 ASC",
+                        query.toString());
     }
 
     public void testOrderByWithDefaultSchema() throws Exception
@@ -516,8 +516,8 @@ public class SqlBuilderTest extends Base
             Query query = SqlBuilder.buildQuery(criteria);
             assertEquals(
                     "SELECT table.column1 FROM schema1.table "
-                        + "ORDER BY table.column1 ASC",
-                    query.toString());
+                            + "ORDER BY table.column1 ASC",
+                            query.toString());
         }
         finally
         {
@@ -533,8 +533,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT count(table.column1) FROM table "
-                    + "ORDER BY count(table.column1) ASC",
-                query.toString());
+                        + "ORDER BY count(table.column1) ASC",
+                        query.toString());
     }
 
     public void testOrderByWithAsColumn() throws Exception
@@ -545,9 +545,9 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN1 AS asColumn "
-                    + "FROM TABLE "
-                    + "ORDER BY asColumn ASC",
-                query.toString());
+                        + "FROM TABLE "
+                        + "ORDER BY asColumn ASC",
+                        query.toString());
     }
 
     public void testOrderByWithAsColumnIgnoreCase() throws Exception
@@ -558,9 +558,9 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN1 AS asColumn, UPPER(asColumn) "
-                    + "FROM TABLE "
-                    + "ORDER BY UPPER(asColumn) ASC",
-                query.toString());
+                        + "FROM TABLE "
+                        + "ORDER BY UPPER(asColumn) ASC",
+                        query.toString());
     }
 
     public void testOrderByWithAsColumnAndAliasIgnoreCase() throws Exception
@@ -574,9 +574,9 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT alias.COLUMN1 AS asColumn, UPPER(asColumn) "
-                    + "FROM TABLE alias "
-                    + "ORDER BY UPPER(asColumn) ASC",
-                query.toString());
+                        + "FROM TABLE alias "
+                        + "ORDER BY UPPER(asColumn) ASC",
+                        query.toString());
     }
 
     public void testOrderByAscendingIgnoreCaseString() throws Exception
@@ -587,8 +587,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT UPPER(TABLE.COLUMN1) FROM TABLE "
-                    + "ORDER BY UPPER(TABLE.COLUMN1) ASC",
-                query.toString());
+                        + "ORDER BY UPPER(TABLE.COLUMN1) ASC",
+                        query.toString());
     }
 
     public void testOrderByAscendingIgnoreCaseInteger() throws Exception
@@ -599,8 +599,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN4 FROM TABLE "
-                    + "ORDER BY TABLE.COLUMN4 ASC",
-                query.toString());
+                        + "ORDER BY TABLE.COLUMN4 ASC",
+                        query.toString());
     }
 
     public void testOrderByAscendingIgnoreCaseStringInCriteria()
@@ -613,8 +613,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT UPPER(TABLE.COLUMN1) FROM TABLE "
-                    + "ORDER BY UPPER(TABLE.COLUMN1) ASC",
-                query.toString());
+                        + "ORDER BY UPPER(TABLE.COLUMN1) ASC",
+                        query.toString());
     }
 
     public void testOrderByAscendingIgnoreCaseIntegerInCriteria()
@@ -627,8 +627,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN4 FROM TABLE "
-                    + "ORDER BY TABLE.COLUMN4 ASC",
-                query.toString());
+                        + "ORDER BY TABLE.COLUMN4 ASC",
+                        query.toString());
     }
 
     public void testOrderByDescendingIgnoreCaseString() throws Exception
@@ -639,8 +639,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT UPPER(TABLE.COLUMN1) FROM TABLE "
-                    + "ORDER BY UPPER(TABLE.COLUMN1) DESC",
-                query.toString());
+                        + "ORDER BY UPPER(TABLE.COLUMN1) DESC",
+                        query.toString());
     }
 
     public void testOrderByDescendingIgnoreCaseInteger() throws Exception
@@ -651,8 +651,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN4 FROM TABLE "
-                    + "ORDER BY TABLE.COLUMN4 DESC",
-                query.toString());
+                        + "ORDER BY TABLE.COLUMN4 DESC",
+                        query.toString());
     }
 
     public void testOrderByDescendingIgnoreCaseStringInCriteria()
@@ -665,8 +665,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT UPPER(TABLE.COLUMN1) FROM TABLE "
-                    + "ORDER BY UPPER(TABLE.COLUMN1) DESC",
-                query.toString());
+                        + "ORDER BY UPPER(TABLE.COLUMN1) DESC",
+                        query.toString());
     }
 
     public void testOrderByDescendingIgnoreCaseIntegerInCriteria()
@@ -679,8 +679,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN4 FROM TABLE "
-                    + "ORDER BY TABLE.COLUMN4 DESC",
-                query.toString());
+                        + "ORDER BY TABLE.COLUMN4 DESC",
+                        query.toString());
     }
 
     public void testAlias() throws Exception
@@ -708,7 +708,7 @@ public class SqlBuilderTest extends Base
             assertEquals(
                     "SELECT alias.column1 FROM schema1.table alias",
                     query.toString());
-            }
+        }
         finally
         {
             database.setSchema(oldSchema);
@@ -725,16 +725,16 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT alias.column1 FROM table alias "
-                   + "WHERE UPPER(alias.column1)=UPPER(?)",
-                query.toString());
+                        + "WHERE UPPER(alias.column1)=UPPER(?)",
+                        query.toString());
     }
 
     public void testAliasWithSubquery() throws Exception
     {
         Criteria subquery = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column1"))
-            .where(new ColumnImpl("table2.column2"),
-                    new ColumnImpl("table2.column3"));
+                .addSelectColumn(new ColumnImpl("table2.column1"))
+                .where(new ColumnImpl("table2.column2"),
+                        new ColumnImpl("table2.column3"));
 
         Criteria criteria = new Criteria();
         criteria.addAlias("alias", subquery);
@@ -744,18 +744,18 @@ public class SqlBuilderTest extends Base
 
         assertEquals(
                 "SELECT alias.column1 FROM ("
-                   + "SELECT table2.column1 FROM table2 "
-                   + "WHERE table2.column2=table2.column3) "
-                   + "alias",
-                query.toString());
+                        + "SELECT table2.column1 FROM table2 "
+                        + "WHERE table2.column2=table2.column3) "
+                        + "alias",
+                        query.toString());
         assertEquals(0, query.getPreparedStatementReplacements().size());
     }
 
     public void testAliasWithSubqueryAndReplacements() throws Exception
     {
         Criteria subquery = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column1"))
-            .where(new ColumnImpl("table2.column2"), "x");
+                .addSelectColumn(new ColumnImpl("table2.column1"))
+                .where(new ColumnImpl("table2.column2"), "x");
 
         Criteria criteria = new Criteria();
         criteria.addAlias("alias", subquery);
@@ -765,10 +765,10 @@ public class SqlBuilderTest extends Base
 
         assertEquals(
                 "SELECT alias.column1 FROM ("
-                   + "SELECT table2.column1 FROM table2 "
-                   + "WHERE table2.column2=?) "
-                   + "alias",
-                query.toString());
+                        + "SELECT table2.column1 FROM table2 "
+                        + "WHERE table2.column2=?) "
+                        + "alias",
+                        query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals("x", query.getPreparedStatementReplacements().get(0));
     }
@@ -783,8 +783,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT alias.COLUMN1 FROM TABLE alias "
-                   + "WHERE UPPER(alias.COLUMN1)=UPPER(?)",
-                query.toString());
+                        + "WHERE UPPER(alias.COLUMN1)=UPPER(?)",
+                        query.toString());
     }
 
     public void testAliasWithIgnoreCaseIntegerColumnType() throws Exception
@@ -797,8 +797,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT alias.COLUMN4 FROM TABLE alias "
-                   + "WHERE alias.COLUMN4=?",
-                query.toString());
+                        + "WHERE alias.COLUMN4=?",
+                        query.toString());
     }
 
     public void testAliasWithIgnoreCaseStringColumnTypeAndDefaultSchema()
@@ -817,8 +817,8 @@ public class SqlBuilderTest extends Base
             Query query = SqlBuilder.buildQuery(criteria);
             assertEquals(
                     "SELECT alias.COLUMN1 FROM schema1.TABLE alias "
-                       + "WHERE UPPER(alias.COLUMN1)=UPPER(?)",
-                    query.toString());
+                            + "WHERE UPPER(alias.COLUMN1)=UPPER(?)",
+                            query.toString());
         }
         finally
         {
@@ -842,8 +842,8 @@ public class SqlBuilderTest extends Base
             Query query = SqlBuilder.buildQuery(criteria);
             assertEquals(
                     "SELECT alias.COLUMN4 FROM schema1.TABLE alias "
-                       + "WHERE alias.COLUMN4=?",
-                    query.toString());
+                            + "WHERE alias.COLUMN4=?",
+                            query.toString());
         }
         finally
         {
@@ -870,8 +870,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT table.column AS columnAlias FROM table"
-                    + " WHERE UPPER(columnAlias)=UPPER(?)",
-                query.toString());
+                        + " WHERE UPPER(columnAlias)=UPPER(?)",
+                        query.toString());
     }
 
     public void testAsColumnWithIgnoreCaseStringColumn() throws Exception
@@ -883,8 +883,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN1 AS columnAlias FROM TABLE"
-                    + " WHERE UPPER(columnAlias)=UPPER(?)",
-                query.toString());
+                        + " WHERE UPPER(columnAlias)=UPPER(?)",
+                        query.toString());
     }
 
     public void testAsColumnWithIgnoreCaseIntegerColumn() throws Exception
@@ -896,8 +896,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT TABLE.COLUMN4 AS columnAlias FROM TABLE"
-                    + " WHERE columnAlias=?",
-                query.toString());
+                        + " WHERE columnAlias=?",
+                        query.toString());
     }
 
     public void testAsColumnWithIgnoreCaseStringColumnAndDefaultSchema()
@@ -916,8 +916,8 @@ public class SqlBuilderTest extends Base
             Query query = SqlBuilder.buildQuery(criteria);
             assertEquals(
                     "SELECT TABLE.COLUMN1 AS columnAlias FROM schema1.TABLE"
-                        + " WHERE UPPER(columnAlias)=UPPER(?)",
-                    query.toString());
+                            + " WHERE UPPER(columnAlias)=UPPER(?)",
+                            query.toString());
         }
         finally
         {
@@ -941,8 +941,8 @@ public class SqlBuilderTest extends Base
             Query query = SqlBuilder.buildQuery(criteria);
             assertEquals(
                     "SELECT TABLE.COLUMN4 AS columnAlias FROM schema1.TABLE"
-                        + " WHERE columnAlias=?",
-                    query.toString());
+                            + " WHERE columnAlias=?",
+                            query.toString());
         }
         finally
         {
@@ -961,8 +961,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT table1.column FROM table1, table2"
-                    + " WHERE table1.column1=table2.column2",
-                query.toString());
+                        + " WHERE table1.column1=table2.column2",
+                        query.toString());
     }
 
     public void testInnerJoinImplicitWithComparison()
@@ -974,15 +974,15 @@ public class SqlBuilderTest extends Base
                 "table1",
                 "table2",
                 new Criterion(
-                    new ColumnImpl("table1.column1"),
-                    new ColumnImpl("table2.column2"),
-                    SqlEnum.NOT_EQUAL),
+                        new ColumnImpl("table1.column1"),
+                        new ColumnImpl("table2.column2"),
+                        SqlEnum.NOT_EQUAL),
                 null);
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT table1.column FROM table1, table2"
-                    + " WHERE table1.column1<>table2.column2",
-                query.toString());
+                        + " WHERE table1.column1<>table2.column2",
+                        query.toString());
     }
 
     public void testInnerJoinExplicit()
@@ -997,8 +997,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT table1.column1 FROM table1 INNER JOIN table2"
-                    + " ON table1.column1=table2.column2",
-                query.toString());
+                        + " ON table1.column1=table2.column2",
+                        query.toString());
     }
 
     public void testInnerJoinWithExcplicitExistingRightTable()
@@ -1019,11 +1019,11 @@ public class SqlBuilderTest extends Base
         // first join condition
         assertEquals(
                 "SELECT table1.column1"
-                    + " FROM table2 INNER JOIN table3"
-                    + " ON table2.column2=table3.column3"
-                    + " INNER JOIN table1"
-                    + " ON table1.column1=table2.column2",
-                query.toString());
+                        + " FROM table2 INNER JOIN table3"
+                        + " ON table2.column2=table3.column3"
+                        + " INNER JOIN table1"
+                        + " ON table1.column1=table2.column2",
+                        query.toString());
     }
 
     public void testInnerJoinWithExcplicitExistingRightTableAndOperator()
@@ -1035,28 +1035,28 @@ public class SqlBuilderTest extends Base
                 "table2",
                 "table3",
                 new Criterion(
-                    new ColumnImpl("table2.column2"),
-                    new ColumnImpl("table3.column3"),
-                    Criteria.LESS_THAN),
+                        new ColumnImpl("table2.column2"),
+                        new ColumnImpl("table3.column3"),
+                        Criteria.LESS_THAN),
                 Criteria.INNER_JOIN);
         criteria.addJoin(
                 "table1",
                 "table2",
                 new Criterion(
-                    new ColumnImpl("table1.column1"),
-                    new ColumnImpl("table2.column2"),
-                    Criteria.GREATER_THAN),
+                        new ColumnImpl("table1.column1"),
+                        new ColumnImpl("table2.column2"),
+                        Criteria.GREATER_THAN),
                 Criteria.INNER_JOIN);
         Query query = SqlBuilder.buildQuery(criteria);
         // second join condition must be changed in order to satisfy
         // first join condition
         assertEquals(
                 "SELECT table1.column1"
-                    + " FROM table2 INNER JOIN table3"
-                    + " ON table2.column2<table3.column3"
-                    + " INNER JOIN table1"
-                    + " ON table1.column1>table2.column2",
-                query.toString());
+                        + " FROM table2 INNER JOIN table3"
+                        + " ON table2.column2<table3.column3"
+                        + " INNER JOIN table1"
+                        + " ON table1.column1>table2.column2",
+                        query.toString());
     }
 
     public void testInnerJoinExcplicitWithExistingRightAndLeftTable()
@@ -1086,7 +1086,7 @@ public class SqlBuilderTest extends Base
             assertEquals("Unable to create a INNER JOIN "
                     + "because both expressions table1 and table2 "
                     + "are already in use. Try to create an(other) alias.",
-                e.getMessage());
+                    e.getMessage());
         }
     }
 
@@ -1113,10 +1113,10 @@ public class SqlBuilderTest extends Base
 
         assertEquals(
                 "SELECT table1.column1 FROM table1 INNER JOIN table2 "
-                   + "ON (table1.column2=? "
-                   + "AND UPPER(?)<>UPPER(table2.column2) "
-                   + "AND table1.column2=table2.column2)",
-                query.toString());
+                        + "ON (table1.column2=? "
+                        + "AND UPPER(?)<>UPPER(table2.column2) "
+                        + "AND table1.column2=table2.column2)",
+                        query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals("x", query.getPreparedStatementReplacements().get(0));
         assertEquals("y", query.getPreparedStatementReplacements().get(1));
@@ -1130,8 +1130,8 @@ public class SqlBuilderTest extends Base
     public void testInnerJoinExplicitWithSubselect() throws Exception
     {
         Criteria subselect = new Criteria()
-            .where(new ColumnImpl("table2.column2"), 5)
-            .addSelectColumn(new ColumnImpl("table2.column1"));
+                .where(new ColumnImpl("table2.column2"), 5)
+                .addSelectColumn(new ColumnImpl("table2.column1"));
         Query subselectQuery = SqlBuilder.buildQuery(subselect);
         PreparedStatementPart fromClause = new PreparedStatementPartImpl(
                 "(" + subselectQuery.toString() + ") alias",
@@ -1139,18 +1139,18 @@ public class SqlBuilderTest extends Base
         Criterion join = new Criterion(new ColumnImpl("table1.column1"), new ColumnImpl("alias.column1"));
 
         Criteria criteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table1.column1"))
-            .addJoin(new PreparedStatementPartImpl("table1"), fromClause, join, Criteria.INNER_JOIN)
-            .where(new ColumnImpl("table1.column3"), 3);
+                .addSelectColumn(new ColumnImpl("table1.column1"))
+                .addJoin(new PreparedStatementPartImpl("table1"), fromClause, join, Criteria.INNER_JOIN)
+                .where(new ColumnImpl("table1.column3"), 3);
 
         Query query = SqlBuilder.buildQuery(criteria);
 
         assertEquals(
                 "SELECT table1.column1 FROM table1 INNER JOIN "
-                   + "(SELECT table2.column1 FROM table2 WHERE table2.column2=?) alias"
-                   + " ON table1.column1=alias.column1"
-                   + " WHERE table1.column3=?",
-                query.toString());
+                        + "(SELECT table2.column1 FROM table2 WHERE table2.column2=?) alias"
+                        + " ON table1.column1=alias.column1"
+                        + " WHERE table1.column3=?",
+                        query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(5, query.getPreparedStatementReplacements().get(0));
         assertEquals(3, query.getPreparedStatementReplacements().get(1));
@@ -1195,9 +1195,9 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT table1.column1"
-                    + " FROM table1 LEFT JOIN table2"
-                    + " ON table1.column=table2.column",
-                query.toString());
+                        + " FROM table1 LEFT JOIN table2"
+                        + " ON table1.column=table2.column",
+                        query.toString());
     }
 
     public void testLeftJoinWithExistingRightTable()
@@ -1219,11 +1219,11 @@ public class SqlBuilderTest extends Base
         // first join condition
         assertEquals(
                 "SELECT table1.column1"
-                    + " FROM table2 INNER JOIN table3"
-                    + " ON table2.column2=table3.column3"
-                    + " RIGHT JOIN table1"
-                    + " ON table1.column1=table2.column2",
-                query.toString());
+                        + " FROM table2 INNER JOIN table3"
+                        + " ON table2.column2=table3.column3"
+                        + " RIGHT JOIN table1"
+                        + " ON table1.column1=table2.column2",
+                        query.toString());
     }
 
     public void testRightJoin()
@@ -1238,9 +1238,9 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT table1.column1"
-                    + " FROM table1 RIGHT JOIN table2"
-                    + " ON table1.column=table2.column",
-                query.toString());
+                        + " FROM table1 RIGHT JOIN table2"
+                        + " ON table1.column=table2.column",
+                        query.toString());
     }
 
     public void testRightJoinWithExistingRightTable()
@@ -1262,11 +1262,11 @@ public class SqlBuilderTest extends Base
         // first join condition
         assertEquals(
                 "SELECT table1.column1"
-                    + " FROM table2 INNER JOIN table3"
-                    + " ON table2.column2=table3.column3"
-                    + " LEFT JOIN table1"
-                    + " ON table1.column1=table2.column2",
-                query.toString());
+                        + " FROM table2 INNER JOIN table3"
+                        + " ON table2.column2=table3.column3"
+                        + " LEFT JOIN table1"
+                        + " ON table1.column1=table2.column2",
+                        query.toString());
     }
 
     public void testInnerJoinImplicitWithAlias()
@@ -1281,8 +1281,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT alias.column1 FROM table1 alias, table2"
-                    + " WHERE alias.column=table2.column",
-                query.toString());
+                        + " WHERE alias.column=table2.column",
+                        query.toString());
     }
 
     public void testInnerJoinImplicitWithAliasAndAsColumn()
@@ -1295,8 +1295,8 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT alias.column AS x FROM table2, table1 alias"
-                    + " WHERE x=table2.column",
-                query.toString());
+                        + " WHERE x=table2.column",
+                        query.toString());
     }
 
 
@@ -1316,9 +1316,9 @@ public class SqlBuilderTest extends Base
             Query query = SqlBuilder.buildQuery(criteria);
             assertEquals(
                     "SELECT *"
-                        + " FROM schema1.table1, schema1.table2"
-                        + " WHERE table1.column=table2.column",
-                    query.toString());
+                            + " FROM schema1.table1, schema1.table2"
+                            + " WHERE table1.column=table2.column",
+                            query.toString());
         }
         finally
         {
@@ -1343,8 +1343,8 @@ public class SqlBuilderTest extends Base
             Query query = SqlBuilder.buildQuery(criteria);
             assertEquals(
                     "SELECT alias.column1 FROM schema1.table1 alias, schema1.table2"
-                        + " WHERE alias.column=table2.column",
-                    query.toString());
+                            + " WHERE alias.column=table2.column",
+                            query.toString());
         }
         finally
         {
@@ -1365,16 +1365,16 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT alias.column1 FROM schema1.table1 alias, schema2.table2"
-                    + " WHERE alias.column=table2.column",
-                query.toString());
+                        + " WHERE alias.column=table2.column",
+                        query.toString());
     }
 
     public void testInnerJoinImplicitWithSubqueryAndReplacements()
             throws Exception
     {
         Criteria subquery = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column2a"))
-            .where(new ColumnImpl("table2.column2b"), "x");
+                .addSelectColumn(new ColumnImpl("table2.column2a"))
+                .where(new ColumnImpl("table2.column2b"), "x");
 
         Criteria criteria = new Criteria();
         criteria.addSelectColumn(new ColumnImpl("alias.column1"));
@@ -1387,11 +1387,11 @@ public class SqlBuilderTest extends Base
 
         assertEquals(
                 "SELECT alias.column1 FROM ("
-                   + "SELECT table2.column2a FROM table2 "
-                   + "WHERE table2.column2b=?) "
-                   + "alias, table2 "
-                   + "WHERE alias.column1=table2.column2",
-                query.toString());
+                        + "SELECT table2.column2a FROM table2 "
+                        + "WHERE table2.column2b=?) "
+                        + "alias, table2 "
+                        + "WHERE alias.column1=table2.column2",
+                        query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals("x", query.getPreparedStatementReplacements().get(0));
     }
@@ -1420,11 +1420,11 @@ public class SqlBuilderTest extends Base
 
         assertEquals(
                 "SELECT table1.column1 FROM table1, table2 "
-                   + "WHERE (table1.column2=? "
-                   + "AND UPPER(?)<>UPPER(table2.column2) "
-                   + "AND table1.column2=table2.column2) "
-                   + "AND table1.column3 IS NULL",
-                query.toString());
+                        + "WHERE (table1.column2=? "
+                        + "AND UPPER(?)<>UPPER(table2.column2) "
+                        + "AND table1.column2=table2.column2) "
+                        + "AND table1.column3 IS NULL",
+                        query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals("x", query.getPreparedStatementReplacements().get(0));
         assertEquals("y", query.getPreparedStatementReplacements().get(1));
@@ -1463,7 +1463,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT TABLE.COLUMN1 FROM TABLE "
                 + "LIMIT 20",
-            query.toString());
+                query.toString());
     }
 
     public void testOffsetPostgresql() throws Exception
@@ -1475,7 +1475,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT TABLE.COLUMN1 FROM TABLE "
                 + "OFFSET 10",
-            query.toString());
+                query.toString());
     }
 
     public void testLimitOffsetPostgresql() throws Exception
@@ -1488,7 +1488,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT TABLE.COLUMN1 FROM TABLE "
                 + "LIMIT 20 OFFSET 10",
-            query.toString());
+                query.toString());
     }
 
     public void testLimitMysql() throws Exception
@@ -1500,7 +1500,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT TABLE.COLUMN1 FROM TABLE "
                 + "LIMIT 20",
-            query.toString());
+                query.toString());
     }
 
     public void testOffsetMysql() throws Exception
@@ -1512,7 +1512,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT TABLE.COLUMN1 FROM TABLE "
                 + "LIMIT 18446744073709551615 OFFSET 10",
-            query.toString());
+                query.toString());
     }
 
     public void testLimitOffsetMysql() throws Exception
@@ -1525,7 +1525,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT TABLE.COLUMN1 FROM TABLE "
                 + "LIMIT 20 OFFSET 10",
-            query.toString());
+                query.toString());
     }
 
     public void testLimitOracle() throws Exception
@@ -1539,7 +1539,7 @@ public class SqlBuilderTest extends Base
                 + " SELECT A.*, rownum AS TORQUE$ROWNUM FROM "
                 + "( SELECT TABLE.COLUMN1 FROM TABLE ) A  ) B"
                 + " WHERE  B.TORQUE$ROWNUM <= 20",
-            query.toString());
+                query.toString());
     }
 
     public void testOffsetOracle() throws Exception
@@ -1553,7 +1553,7 @@ public class SqlBuilderTest extends Base
                 + " SELECT A.*, rownum AS TORQUE$ROWNUM FROM "
                 + "( SELECT TABLE.COLUMN1 FROM TABLE ) A  ) B"
                 + " WHERE  B.TORQUE$ROWNUM > 10",
-            query.toString());
+                query.toString());
     }
 
     public void testLimitOffsetOracle() throws Exception
@@ -1568,16 +1568,16 @@ public class SqlBuilderTest extends Base
                 + " SELECT A.*, rownum AS TORQUE$ROWNUM FROM "
                 + "( SELECT TABLE.COLUMN1 FROM TABLE ) A  ) B"
                 + " WHERE  B.TORQUE$ROWNUM > 10 AND B.TORQUE$ROWNUM <= 30",
-            query.toString());
+                query.toString());
     }
 
     public void testSelectForUpdate() throws Exception
     {
         Criteria criteria = new Criteria()
-            .addSelectColumn(stringColumnMap)
-            .setLimit(20)
-            .setOffset(10)
-            .forUpdate();
+                .addSelectColumn(stringColumnMap)
+                .setLimit(20)
+                .setOffset(10)
+                .forUpdate();
         criteria.setDbName(databaseOracle.getName());
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT B.* FROM ("
@@ -1585,7 +1585,7 @@ public class SqlBuilderTest extends Base
                 + "( SELECT TABLE.COLUMN1 FROM TABLE ) A  ) B"
                 + " WHERE  B.TORQUE$ROWNUM > 10 AND B.TORQUE$ROWNUM <= 30"
                 + " FOR UPDATE",
-            query.toString());
+                query.toString());
     }
 
     public void testHaving() throws Exception
@@ -1599,7 +1599,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT TABLE.COLUMN1, count(*) AS count FROM TABLE "
                 + "GROUP BY TABLE.COLUMN1 HAVING count>=10",
-            query.toString());
+                query.toString());
     }
 
     public void testSelectColumnWithoutTable()
@@ -1617,7 +1617,7 @@ public class SqlBuilderTest extends Base
         Criteria criteria = new Criteria();
         criteria.addSelectColumn(new ColumnImpl("table.column"));
         Criterion criterion
-                = new Criterion("A", null, null, "A = functionOf(B)", null);
+        = new Criterion("A", null, null, "A = functionOf(B)", null);
         criteria.where(criterion);
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table WHERE A = functionOf(B)",
@@ -1646,7 +1646,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table "
                 + "WHERE column=CURRENT_DATE",
-            query.toString());
+                query.toString());
         assertEquals(0, query.getPreparedStatementReplacements().size());
     }
 
@@ -1658,7 +1658,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table "
                 + "WHERE column=CURRENT_TIME",
-            query.toString());
+                query.toString());
         assertEquals(0, query.getPreparedStatementReplacements().size());
     }
 
@@ -1670,7 +1670,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table "
                 + "WHERE column=CURRENT_TIMESTAMP",
-            query.toString());
+                query.toString());
         assertEquals(0, query.getPreparedStatementReplacements().size());
     }
 
@@ -1682,7 +1682,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table "
                 + "WHERE column=?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 new BigDecimal(11),
@@ -1697,7 +1697,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table "
                 + "WHERE column IS NULL",
-            query.toString());
+                query.toString());
         assertEquals(0, query.getPreparedStatementReplacements().size());
     }
 
@@ -1712,7 +1712,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table "
                 + "WHERE column IS NOT NULL",
-            query.toString());
+                query.toString());
         assertEquals(0, query.getPreparedStatementReplacements().size());
     }
 
@@ -1727,7 +1727,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table "
                 + "WHERE column IS NOT NULL",
-            query.toString());
+                query.toString());
         assertEquals(0, query.getPreparedStatementReplacements().size());
     }
 
@@ -1742,7 +1742,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table "
                 + "WHERE column IS NULL",
-            query.toString());
+                query.toString());
         assertEquals(0, query.getPreparedStatementReplacements().size());
     }
 
@@ -1757,7 +1757,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column FROM table "
                 + "WHERE column IS NOT NULL",
-            query.toString());
+                query.toString());
         assertEquals(0, query.getPreparedStatementReplacements().size());
     }
 
@@ -1776,7 +1776,7 @@ public class SqlBuilderTest extends Base
                 + "WHERE table.column3=("
                 + "SELECT table.column3 FROM table "
                 + "WHERE table.column2=?)",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals("value2", query.getPreparedStatementReplacements().get(0));
     }
@@ -1784,19 +1784,19 @@ public class SqlBuilderTest extends Base
     public void testSubselectReferenceOuterTable() throws Exception
     {
         Criteria subselect = new Criteria()
-            .where(new ColumnImpl("table.column1"), new ColumnImpl("table2.column2"))
-            .and(new ColumnImpl("table.column2"), 2)
-            .addSelectColumn(new Count("*"));
+                .where(new ColumnImpl("table.column1"), new ColumnImpl("table2.column2"))
+                .and(new ColumnImpl("table.column2"), 2)
+                .addSelectColumn(new Count("*"));
 
         Criteria criteria = new Criteria()
-            .where(subselect, 1)
-            .addSelectColumn(new ColumnImpl("table.column1"));
+                .where(subselect, 1)
+                .addSelectColumn(new ColumnImpl("table.column1"));
 
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals(
                 "SELECT table.column1 FROM table WHERE "
-                + "(SELECT COUNT(*) FROM table2 WHERE (table.column1=table2.column2 AND table.column2=?))=?",
-            query.toString());
+                        + "(SELECT COUNT(*) FROM table2 WHERE (table.column1=table2.column2 AND table.column2=?))=?",
+                        query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(2, query.getPreparedStatementReplacements().get(0));
         assertEquals(1, query.getPreparedStatementReplacements().get(1));
@@ -1814,7 +1814,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 LIKE ?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "%v%al_e2_",
@@ -1836,7 +1836,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 LIKE ?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "*v\\%al\\_e\\\\%2?\\",
@@ -1860,7 +1860,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 LIKE ? ESCAPE '\\'",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "*v\\%al\\_e\\\\%2?\\",
@@ -1880,7 +1880,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 ILIKE ?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "%v%al_e2_",
@@ -1900,7 +1900,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE UPPER(table.column2)=UPPER(?)",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "value\\2",
@@ -1937,7 +1937,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 NOT LIKE ?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "%val_e2_",
@@ -1957,7 +1957,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 NOT ILIKE ?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "%v%al_e2_",
@@ -1977,7 +1977,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE UPPER(table.column2)<>UPPER(?)",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "value\\2",
@@ -1996,7 +1996,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 ILIKE ?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "%val_e2_",
@@ -2015,7 +2015,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 ILIKE ?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "value2",
@@ -2034,7 +2034,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 NOT ILIKE ?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "%val_e2_",
@@ -2053,7 +2053,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE table.column2 NOT ILIKE ?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(
                 "value2",
@@ -2083,8 +2083,8 @@ public class SqlBuilderTest extends Base
         criteria.addSelectColumn(new ColumnImpl("table.column"));
         try
         {
-          criteria.where(null, new ColumnImpl("table.column"));
-          fail("Exception expected");
+            criteria.where(null, new ColumnImpl("table.column"));
+            fail("Exception expected");
         }
         catch (IllegalArgumentException e)
         {
@@ -2119,7 +2119,7 @@ public class SqlBuilderTest extends Base
 
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE (table.column2 IN (?,?) OR table.column2 IS NULL)",
-            query.toString());
+                query.toString());
         List<Object> replacements = query.getPreparedStatementReplacements();
         assertEquals(2, replacements.size());
         assertEquals(inValue[0], replacements.get(0));
@@ -2139,7 +2139,7 @@ public class SqlBuilderTest extends Base
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE (UPPER(table.column2) IN (UPPER(?),UPPER(?))"
                 + " OR table.column2 IS NULL)",
-            query.toString());
+                query.toString());
         List<Object> replacements = query.getPreparedStatementReplacements();
         assertEquals(2, replacements.size());
         assertEquals(inValue[0], replacements.get(0));
@@ -2150,7 +2150,7 @@ public class SqlBuilderTest extends Base
     {
         Criteria criteria = new Criteria();
         criteria.addSelectColumn(new ColumnImpl("table.column1"));
-        List<Integer> inList = new ArrayList<Integer>();
+        List<Integer> inList = new ArrayList<>();
         inList.add(1);
         inList.add(null);
         inList.add(2);
@@ -2160,7 +2160,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE (table.column2 IN (?,?) OR table.column2 IS NULL)",
-            query.toString());
+                query.toString());
         assertEquals(
                 2,
                 query.getPreparedStatementReplacements().size());
@@ -2169,10 +2169,10 @@ public class SqlBuilderTest extends Base
     }
 
     public void testInListIgnoreCase() throws Exception
-        {
+    {
         Criteria criteria = new Criteria();
         criteria.addSelectColumn(new ColumnImpl("table.column1"));
-        List<String> inList = new ArrayList<String>();
+        List<String> inList = new ArrayList<>();
         inList.add("a");
         inList.add("b");
         inList.add(null);
@@ -2184,7 +2184,7 @@ public class SqlBuilderTest extends Base
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE (UPPER(table.column2) IN (UPPER(?),UPPER(?))"
                 + " OR table.column2 IS NULL)",
-            query.toString());
+                query.toString());
         List<Object> replacements = query.getPreparedStatementReplacements();
         assertEquals(2, replacements.size());
         assertEquals("a", replacements.get(0));
@@ -2195,7 +2195,7 @@ public class SqlBuilderTest extends Base
     {
         Criteria criteria = new Criteria();
         criteria.addSelectColumn(new ColumnImpl("table.column1"));
-        List<Integer> inList = new ArrayList<Integer>();
+        List<Integer> inList = new ArrayList<>();
         inList.add(1);
         inList.add(null);
         inList.add(2);
@@ -2209,7 +2209,7 @@ public class SqlBuilderTest extends Base
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE (table.column2 NOT IN (?,?) "
                 + "AND table.column2 IS NOT NULL)",
-            query.toString());
+                query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(1, query.getPreparedStatementReplacements().get(0));
         assertEquals(2, query.getPreparedStatementReplacements().get(1));
@@ -2233,7 +2233,7 @@ public class SqlBuilderTest extends Base
         assertEquals(size, replacements.size());
         assertTrue("Exceeded time limit of " + LARGE_ARRAY_TIME_LIMIT
                 + " ms. Execution time was " + (end - start) + " ms",
-            end - start < LARGE_ARRAY_TIME_LIMIT);
+                end - start < LARGE_ARRAY_TIME_LIMIT);
     }
 
     public void testInString() throws Exception
@@ -2254,7 +2254,7 @@ public class SqlBuilderTest extends Base
         {
             assertEquals("Unknown rValue type java.lang.String. "
                     + "rValue must be an instance of  Iterable or Array",
-            e.getMessage());
+                    e.getMessage());
         }
     }
 
@@ -2268,7 +2268,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table1.column1 FROM table3 "
                 + "WHERE table2.column2=?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(1, query.getPreparedStatementReplacements().get(0));
     }
@@ -2283,7 +2283,7 @@ public class SqlBuilderTest extends Base
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table1.column1 FROM table3 "
                 + "WHERE table2.column2=?",
-            query.toString());
+                query.toString());
         assertEquals(1, query.getPreparedStatementReplacements().size());
         assertEquals(1, query.getPreparedStatementReplacements().get(0));
     }
@@ -2292,9 +2292,9 @@ public class SqlBuilderTest extends Base
     public void testUnion() throws Exception
     {
         Criteria criteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column2"))
-            .where(new ColumnImpl("table2.columnb"), 3)
-            .union(new Criteria()
+                .addSelectColumn(new ColumnImpl("table2.column2"))
+                .where(new ColumnImpl("table2.columnb"), 3)
+                .union(new Criteria()
                         .addSelectColumn(new ColumnImpl("table1.column1"))
                         .where(new ColumnImpl("table1.columna"), 1));
         Query query = SqlBuilder.buildQuery(criteria);
@@ -2302,7 +2302,7 @@ public class SqlBuilderTest extends Base
                 + "WHERE table2.columnb=?) "
                 + "UNION (SELECT table1.column1 FROM table1 "
                 + "WHERE table1.columna=?)",
-            query.toString());
+                query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(3, query.getPreparedStatementReplacements().get(0));
         assertEquals(1, query.getPreparedStatementReplacements().get(1));
@@ -2311,9 +2311,9 @@ public class SqlBuilderTest extends Base
     public void testUnionAll() throws Exception
     {
         Criteria criteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column2"))
-            .where(new ColumnImpl("table2.columnb"), 3)
-            .unionAll(new Criteria()
+                .addSelectColumn(new ColumnImpl("table2.column2"))
+                .where(new ColumnImpl("table2.columnb"), 3)
+                .unionAll(new Criteria()
                         .addSelectColumn(new ColumnImpl("table1.column1"))
                         .where(new ColumnImpl("table1.columna"), 1));
         Query query = SqlBuilder.buildQuery(criteria);
@@ -2321,7 +2321,7 @@ public class SqlBuilderTest extends Base
                 + "WHERE table2.columnb=?) "
                 + "UNION ALL (SELECT table1.column1 FROM table1 "
                 + "WHERE table1.columna=?)",
-            query.toString());
+                query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(3, query.getPreparedStatementReplacements().get(0));
         assertEquals(1, query.getPreparedStatementReplacements().get(1));
@@ -2330,9 +2330,9 @@ public class SqlBuilderTest extends Base
     public void testExcept() throws Exception
     {
         Criteria criteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column2"))
-            .where(new ColumnImpl("table2.columnb"), 3)
-            .except(new Criteria()
+                .addSelectColumn(new ColumnImpl("table2.column2"))
+                .where(new ColumnImpl("table2.columnb"), 3)
+                .except(new Criteria()
                         .addSelectColumn(new ColumnImpl("table1.column1"))
                         .where(new ColumnImpl("table1.columna"), 1));
         Query query = SqlBuilder.buildQuery(criteria);
@@ -2340,7 +2340,7 @@ public class SqlBuilderTest extends Base
                 + "WHERE table2.columnb=?) "
                 + "EXCEPT (SELECT table1.column1 FROM table1 "
                 + "WHERE table1.columna=?)",
-            query.toString());
+                query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(3, query.getPreparedStatementReplacements().get(0));
         assertEquals(1, query.getPreparedStatementReplacements().get(1));
@@ -2349,9 +2349,9 @@ public class SqlBuilderTest extends Base
     public void testExceptAll() throws Exception
     {
         Criteria criteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column2"))
-            .where(new ColumnImpl("table2.columnb"), 3)
-            .exceptAll(new Criteria()
+                .addSelectColumn(new ColumnImpl("table2.column2"))
+                .where(new ColumnImpl("table2.columnb"), 3)
+                .exceptAll(new Criteria()
                         .addSelectColumn(new ColumnImpl("table1.column1"))
                         .where(new ColumnImpl("table1.columna"), 1));
         Query query = SqlBuilder.buildQuery(criteria);
@@ -2359,7 +2359,7 @@ public class SqlBuilderTest extends Base
                 + "WHERE table2.columnb=?) "
                 + "EXCEPT ALL (SELECT table1.column1 FROM table1 "
                 + "WHERE table1.columna=?)",
-            query.toString());
+                query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(3, query.getPreparedStatementReplacements().get(0));
         assertEquals(1, query.getPreparedStatementReplacements().get(1));
@@ -2368,9 +2368,9 @@ public class SqlBuilderTest extends Base
     public void testIntersect() throws Exception
     {
         Criteria criteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column2"))
-            .where(new ColumnImpl("table2.columnb"), 3)
-            .intersect(new Criteria()
+                .addSelectColumn(new ColumnImpl("table2.column2"))
+                .where(new ColumnImpl("table2.columnb"), 3)
+                .intersect(new Criteria()
                         .addSelectColumn(new ColumnImpl("table1.column1"))
                         .where(new ColumnImpl("table1.columna"), 1));
         Query query = SqlBuilder.buildQuery(criteria);
@@ -2378,7 +2378,7 @@ public class SqlBuilderTest extends Base
                 + "WHERE table2.columnb=?) "
                 + "INTERSECT (SELECT table1.column1 FROM table1 "
                 + "WHERE table1.columna=?)",
-            query.toString());
+                query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(3, query.getPreparedStatementReplacements().get(0));
         assertEquals(1, query.getPreparedStatementReplacements().get(1));
@@ -2387,9 +2387,9 @@ public class SqlBuilderTest extends Base
     public void testIntersectAll() throws Exception
     {
         Criteria criteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column2"))
-            .where(new ColumnImpl("table2.columnb"), 3)
-            .intersectAll(new Criteria()
+                .addSelectColumn(new ColumnImpl("table2.column2"))
+                .where(new ColumnImpl("table2.columnb"), 3)
+                .intersectAll(new Criteria()
                         .addSelectColumn(new ColumnImpl("table1.column1"))
                         .where(new ColumnImpl("table1.columna"), 1));
         Query query = SqlBuilder.buildQuery(criteria);
@@ -2397,7 +2397,7 @@ public class SqlBuilderTest extends Base
                 + "WHERE table2.columnb=?) "
                 + "INTERSECT ALL (SELECT table1.column1 FROM table1 "
                 + "WHERE table1.columna=?)",
-            query.toString());
+                query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(3, query.getPreparedStatementReplacements().get(0));
         assertEquals(1, query.getPreparedStatementReplacements().get(1));
@@ -2406,14 +2406,14 @@ public class SqlBuilderTest extends Base
     public void testUnionOrderByLimitOffset() throws Exception
     {
         Criteria criteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column2"))
-            .where(new ColumnImpl("table2.columnb"), 3)
-            .union(new Criteria()
+                .addSelectColumn(new ColumnImpl("table2.column2"))
+                .where(new ColumnImpl("table2.columnb"), 3)
+                .union(new Criteria()
                         .addSelectColumn(new ColumnImpl("table1.column1"))
                         .where(new ColumnImpl("table1.columna"), 1))
-            .addAscendingOrderByColumn(new ColumnImpl("table2.column2"))
-            .setLimit(10)
-            .setOffset(20);
+                .addAscendingOrderByColumn(new ColumnImpl("table2.column2"))
+                .setLimit(10)
+                .setOffset(20);
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("(SELECT table2.column2 FROM table2 "
                 + "WHERE table2.columnb=?) "
@@ -2421,7 +2421,7 @@ public class SqlBuilderTest extends Base
                 + "WHERE table1.columna=?)"
                 + " ORDER BY table2.column2 ASC"
                 + " LIMIT 10 OFFSET 20",
-            query.toString());
+                query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals(3, query.getPreparedStatementReplacements().get(0));
         assertEquals(1, query.getPreparedStatementReplacements().get(1));
@@ -2430,18 +2430,18 @@ public class SqlBuilderTest extends Base
     public void testSetOperationBraces() throws Exception
     {
         Criteria criteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table4.column4"))
-            .where(new ColumnImpl("table4.columnd"), 4);
+                .addSelectColumn(new ColumnImpl("table4.column4"))
+                .where(new ColumnImpl("table4.columnd"), 4);
         Criteria otherCriteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table3.column3"))
-            .where(new ColumnImpl("table3.columnc"), 3);
+                .addSelectColumn(new ColumnImpl("table3.column3"))
+                .where(new ColumnImpl("table3.columnc"), 3);
         criteria.unionAll(otherCriteria);
         Criteria intersectCriteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table2.column2"))
-            .where(new ColumnImpl("table2.columnb"), 2);
+                .addSelectColumn(new ColumnImpl("table2.column2"))
+                .where(new ColumnImpl("table2.columnb"), 2);
         otherCriteria = new Criteria()
-            .addSelectColumn(new ColumnImpl("table1.column1"))
-            .where(new ColumnImpl("table1.columna"), 1);
+                .addSelectColumn(new ColumnImpl("table1.column1"))
+                .where(new ColumnImpl("table1.columna"), 1);
         intersectCriteria.unionAll(otherCriteria);
         criteria.intersect(intersectCriteria);
 
@@ -2454,7 +2454,7 @@ public class SqlBuilderTest extends Base
                 + "WHERE table2.columnb=?) "
                 + "UNION ALL (SELECT table1.column1 FROM table1 "
                 + "WHERE table1.columna=?))",
-            query.toString());
+                query.toString());
         assertEquals(4, query.getPreparedStatementReplacements().size());
         assertEquals(4, query.getPreparedStatementReplacements().get(0));
         assertEquals(3, query.getPreparedStatementReplacements().get(1));
@@ -2465,14 +2465,14 @@ public class SqlBuilderTest extends Base
     public void testEnumValues() throws Exception
     {
         Criteria criteria = new Criteria()
-            .where(new ColumnImpl("table.column1"), EnumWithValueMethod.A)
-            .and(EnumWithValueMethod.B, new ColumnImpl("table.column2"))
-            .addSelectColumn(new ColumnImpl("table.column1"));
+                .where(new ColumnImpl("table.column1"), EnumWithValueMethod.A)
+                .and(EnumWithValueMethod.B, new ColumnImpl("table.column2"))
+                .addSelectColumn(new ColumnImpl("table.column1"));
         Query query = SqlBuilder.buildQuery(criteria);
         assertEquals("SELECT table.column1 FROM table "
                 + "WHERE (table.column1=? "
                 + "AND ?=table.column2)",
-            query.toString());
+                query.toString());
         assertEquals(2, query.getPreparedStatementReplacements().size());
         assertEquals("A", query.getPreparedStatementReplacements().get(0));
         assertEquals("B", query.getPreparedStatementReplacements().get(1));
@@ -2484,7 +2484,7 @@ public class SqlBuilderTest extends Base
     public void testEnumValuesNoGetValueMethod() throws Exception
     {
         Criteria criteria = new Criteria()
-        .where(new ColumnImpl("table.column1"), EnumWithoutValueMethod.A);
+                .where(new ColumnImpl("table.column1"), EnumWithoutValueMethod.A);
         try
         {
             SqlBuilder.buildQuery(criteria);
@@ -2495,7 +2495,7 @@ public class SqlBuilderTest extends Base
             assertEquals("An enum is used as Criterion value but its class, "
                     + "org.apache.torque.sql.SqlBuilderTest$EnumWithoutValueMethod, "
                     + "does not have a parameterless getValue() method",
-                e.getMessage());
+                    e.getMessage());
         }
     }
 

Modified: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/BasePeerImplTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/BasePeerImplTest.java?rev=1839288&r1=1839287&r2=1839288&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/BasePeerImplTest.java (original)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/BasePeerImplTest.java Mon Aug 27 09:48:33 2018
@@ -90,7 +90,7 @@ public class BasePeerImplTest extends Ba
     @Override
     public void setUp() throws Exception
     {
-        basePeerImpl = new BasePeerImpl<List<Object>>();
+        basePeerImpl = new BasePeerImpl<>();
         super.setUp();
         basePeerImpl.setTableMap(tableMap);
         basePeerImpl.setDatabaseName("databaseName");
@@ -98,7 +98,7 @@ public class BasePeerImplTest extends Ba
         oldTransactionManager = Transaction.getTransactionManager();
         MockitoAnnotations.initMocks(this);
         when(connection.prepareStatement((String) any()))
-                .thenReturn(preparedStatement);
+        .thenReturn(preparedStatement);
         when(connection.createStatement()).thenReturn(preparedStatement);
         when(preparedStatement.executeQuery()).thenReturn(resultSet);
         when(preparedStatement.executeQuery((String) any())).thenReturn(resultSet);
@@ -108,7 +108,7 @@ public class BasePeerImplTest extends Ba
         when(transactionManager.begin(basePeerImpl.getDatabaseName())).thenReturn(connection);
         when(transactionManager.begin(null)).thenReturn(connection);
         when(idGenerator.getIdAsBigDecimal(connection, null))
-            .thenReturn(DEFAULT_GENERATED_ID);
+        .thenReturn(DEFAULT_GENERATED_ID);
         when(idGenerator.isPriorToInsert()).thenReturn(true);
         when(idGenerator.isPostInsert()).thenReturn(false);
         Transaction.setTransactionManager(transactionManager);
@@ -298,7 +298,7 @@ public class BasePeerImplTest extends Ba
     {
         // prepare
         DatabaseMap fullyQualifiedDatatabaseMap
-            = Torque.getDatabaseMap("fullyQualifiedDatatabaseMap");
+        = Torque.getDatabaseMap("fullyQualifiedDatatabaseMap");
         TableMap tableMap = new TableMap(
                 "schema.fully_qualified_table",
                 fullyQualifiedDatatabaseMap);
@@ -313,7 +313,7 @@ public class BasePeerImplTest extends Ba
         // verify mock
         verify(connection).prepareStatement(
                 "DELETE FROM schema.fully_qualified_table "
-                + "WHERE schema.fully_qualified_table.column=?");
+                        + "WHERE schema.fully_qualified_table.column=?");
         verify(connection).close();
         verify(preparedStatement).setInt(1, 42);
         verify(preparedStatement).executeUpdate();
@@ -419,13 +419,13 @@ public class BasePeerImplTest extends Ba
 
         // execute
         int result = basePeerImpl.doInsert(
-            new Column[] {
-                stringColumnMap2,
-                stringColumnMap3,
-                stringColumnMap,
-                integerColumnMap},
-            criteria,
-            databaseMap.getName());
+                new Column[] {
+                        stringColumnMap2,
+                        stringColumnMap3,
+                        stringColumnMap,
+                        integerColumnMap},
+                criteria,
+                databaseMap.getName());
 
         // verify mock (verification order not relevant)
         verify(connection).prepareStatement(
@@ -546,10 +546,10 @@ public class BasePeerImplTest extends Ba
         // verify mock (verification order not relevant)
         verify(connection).prepareStatement(
                 "UPDATE TABLE SET COLUMN1=?,"
-                + "COLUMN2=TABLE.COLUMN3,"
-                + "COLUMN3=?,"
-                + "COLUMN4=? "
-                + "WHERE TABLE.COLUMN4=?");
+                        + "COLUMN2=TABLE.COLUMN3,"
+                        + "COLUMN3=?,"
+                        + "COLUMN4=? "
+                        + "WHERE TABLE.COLUMN4=?");
         verify(connection).close();
         verify(preparedStatement).executeUpdate();
         verify(preparedStatement).setObject(
@@ -591,9 +591,9 @@ public class BasePeerImplTest extends Ba
         // verify mock (verification order not relevant)
         verify(connection).prepareStatement(
                 "UPDATE TABLE SET COLUMN1=?,"
-                + "COLUMN2=someDbFunction,"
-                + "COLUMN3=? "
-                + "WHERE TABLE.COLUMN4=?");
+                        + "COLUMN2=someDbFunction,"
+                        + "COLUMN3=? "
+                        + "WHERE TABLE.COLUMN4=?");
         verify(connection).close();
         verify(preparedStatement).executeUpdate();
         verify(preparedStatement).setObject(
@@ -622,7 +622,7 @@ public class BasePeerImplTest extends Ba
      */
     public void testExecuteStatementNamed() throws Exception
     {
-        Map<String, JdbcTypedValue> replacementValues = new HashMap<String, JdbcTypedValue>();
+        Map<String, JdbcTypedValue> replacementValues = new HashMap<>();
         replacementValues.put("key1", new JdbcTypedValue(1, 1));
         replacementValues.put("key3", new JdbcTypedValue("3", 3));
 
@@ -649,7 +649,7 @@ public class BasePeerImplTest extends Ba
      */
     public void testExecuteStatementNamedNoReplacements() throws Exception
     {
-        Map<String, JdbcTypedValue> replacementValues = new HashMap<String, JdbcTypedValue>();
+        Map<String, JdbcTypedValue> replacementValues = new HashMap<>();
         replacementValues.put("key1", new JdbcTypedValue(null, 42));
         replacementValues.put("unusedKey", new JdbcTypedValue("3", 3));
 

Modified: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/SummaryHelperTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/SummaryHelperTest.java?rev=1839288&r1=1839287&r2=1839288&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/SummaryHelperTest.java (original)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/SummaryHelperTest.java Mon Aug 27 09:48:33 2018
@@ -121,7 +121,7 @@ public class SummaryHelperTest extends B
         // set up mocks
         MockitoAnnotations.initMocks(this);
         when(connection.prepareStatement((String) any()))
-                .thenReturn(preparedStatement);
+        .thenReturn(preparedStatement);
         when(connection.createStatement()).thenReturn(preparedStatement);
         when(preparedStatement.executeQuery()).thenReturn(resultSet);
         when(preparedStatement.executeQuery((String) any())).thenReturn(resultSet);
@@ -152,7 +152,7 @@ public class SummaryHelperTest extends B
         // verify mock (verification order not relevant)
         verify(connection).prepareStatement(
                 "SELECT COUNT(TABLE.COLUMN1) AS count "
-                + "FROM TABLE WHERE TABLE.COLUMN1=?");
+                        + "FROM TABLE WHERE TABLE.COLUMN1=?");
         verify(preparedStatement).executeQuery();
         verify(preparedStatement).setString(1, "abc");
         verify(preparedStatement).close();

Modified: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/UniqueListTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/UniqueListTest.java?rev=1839288&r1=1839287&r2=1839288&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/UniqueListTest.java (original)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/util/UniqueListTest.java Mon Aug 27 09:48:33 2018
@@ -39,7 +39,7 @@ public class UniqueListTest extends Test
      */
     public void testNull()
     {
-        UniqueList<Object> uniqueList = new UniqueList<Object>();
+        UniqueList<Object> uniqueList = new UniqueList<>();
         Object o = null;
         boolean actualReturn = uniqueList.add(o);
         assertEquals("return value", false, actualReturn);
@@ -50,7 +50,7 @@ public class UniqueListTest extends Test
      */
     public void testUnique()
     {
-        UniqueList<String> uniqueList = new UniqueList<String>();
+        UniqueList<String> uniqueList = new UniqueList<>();
         uniqueList.add("Table");
         uniqueList.add("TableA");
         uniqueList.add("Table");



---------------------------------------------------------------------
To unsubscribe, e-mail: [hidden email]
For additional commands, e-mail: [hidden email]