Cleanup:

- Javadocs
- Work in progress

h2/src/tools/org/h2/jaqu/Query.java

@@ -19,7 +19,6 @@ import org.h2.jaqu.bytecode.ClassReader;
 import org.h2.jaqu.util.StatementLogger;
 import org.h2.jaqu.util.JdbcUtils;
 import org.h2.jaqu.util.Utils;
-//import org.h2.util.JdbcUtils;
 //## Java 1.5 end ##
 
 /**
@@ -38,8 +37,8 @@ public class Query<T> {
     private final IdentityHashMap<Object, SelectColumn<T>> aliasMap = Utils.newIdentityHashMap();
     private ArrayList<OrderExpression<T>> orderByList = Utils.newArrayList();
     private Object[] groupByExpressions;
-    private long limit = 0;
-    private long offset = 0;
+    private long limit;
+    private long offset;
 
     Query(Db db) {
         this.db = db;
@@ -65,6 +64,7 @@ public class Query<T> {
         } catch (SQLException e) {
             throw new RuntimeException(e);
         } finally {
+            int whyTrue;
             JdbcUtils.closeSilently(rs, true);
         }
     }
@@ -120,24 +120,26 @@ public class Query<T> {
         StatementLogger.delete(stat.getSQL());
         return stat.executeUpdate();
     }
-    
+
     public <A> SetColumn<T, A> set(A field) {
+        int renameSetColumnClassToUpdateSetColumn;
         return new SetColumn<T, A>(this, field);
     }
 
     public <A> IncrementColumn<T, A> increment(A field) {
+        int renameIncrementColumnClassToUpdateIncrementColumn;
         return new IncrementColumn<T, A>(this, field);
     }
 
     public int update() {
         if (declarations.size() == 0)
             throw new RuntimeException("Please specify SET or INCREMENT before calling Update!");
-        SQLStatement stat = new SQLStatement(db);                
+        SQLStatement stat = new SQLStatement(db);
         stat.appendSQL("UPDATE ");
         from.appendSQL(stat);
         stat.appendSQL(" SET ");
         int i = 0;
-        for (Declaration declaration:declarations) {
+        for (Declaration declaration : declarations) {
             if (i++ > 0) {
                 stat.appendSQL(", ");
             }
@@ -145,7 +147,7 @@ public class Query<T> {
         }
         appendWhere(stat);
         StatementLogger.update(stat.getSQL());
-        return stat.executeUpdate();        
+        return stat.executeUpdate();
     }
 
     public <X, Z> List<X> selectDistinct(Z x) {
@@ -196,6 +198,7 @@ public class Query<T> {
                 try {
                     X value;
                     Object o = rs.getObject(1);
+                    int convertHereIsProbablyWrong;
                     if (Clob.class.isAssignableFrom(o.getClass())) {
                         value = (X) Utils.convert(o, String.class);
                     } else
@@ -266,7 +269,7 @@ public class Query<T> {
         return this;
     }
 //## Java 1.5 end ##
-    
+
     /**
      * Order by a number of columns.
      *
@@ -323,8 +326,9 @@ public class Query<T> {
     void addConditionToken(Token condition) {
         conditions.add(condition);
     }
-    
+
     void addDeclarationToken(Declaration declaration) {
+    int todoWhatIsDeclaration;
         declarations.add(declaration);
     }
 

h2/src/tools/org/h2/jaqu/QueryWhere.java

@@ -33,12 +33,12 @@ public class QueryWhere<T> {
         query.addConditionToken(ConditionAndOr.OR);
         return new QueryCondition<T, A>(query, x);
     }
-    
+
     public QueryWhere<T> limit(long limit) {
         query.limit(limit);
         return this;
     }
-    
+
     public QueryWhere<T> offset(long offset) {
         query.offset(offset);
         return this;

h2/src/tools/org/h2/jaqu/SQLDialect.java

-/*
- * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License,
- * Version 1.0, and under the Eclipse Public License, Version 1.0
- * (http://h2database.com/html/license.html).
- * Initial Developer: James Moger
- */
-package org.h2.jaqu;
-
-import org.h2.jaqu.TableDefinition.IndexDefinition;
-import org.h2.jaqu.util.StatementBuilder;
-import org.h2.jaqu.util.StringUtils;
-
-/**
- * This interface defines points where JaQu can build different statements
- * depending on the database used.
- */
-public interface SQLDialect {
-
-    /**
-     * Get the SQL snippet for the table name.
-     *
-     * @param schema the schema name, or null for no schema
-     * @param table the table name
-     * @return the SQL snippet
-     */
-    String tableName(String schema, String table);
-
-    /**
-     * Get the CREATE INDEX statement.
-     *
-     * @param schema the schema name
-     * @param table the table name
-     * @param index the index definition
-     * @return the SQL statement
-     */
-    String createIndex(String schema, String table, IndexDefinition index);
-
-    /**
-     * Append "LIMIT limit" to the SQL statement.
-     *
-     * @param stat the statement
-     * @param limit the limit
-     */
-    void appendLimit(SQLStatement stat, long limit);
-
-    /**
-     * Append "OFFSET offset" to the SQL statement.
-     *
-     * @param stat the statement
-     * @param offset the offset
-     */
-    void appendOffset(SQLStatement stat, long offset);
-
-    /**
-     *  Default implementation of an SQL dialect.
-     *  Designed for an H2 database.  May be suitable for others.
-     */
-    public static class DefaultSQLDialect implements SQLDialect {
-
-        public String tableName(String schema, String table) {
-            if (StringUtils.isNullOrEmpty(schema)) {
-                return table;
-            }
-            return schema + "." + table;
-        }
-
-        public String createIndex(String schema, String table, IndexDefinition index) {
-            StatementBuilder buff = new StatementBuilder();
-            buff.append("CREATE ");
-            switch(index.type) {
-            case STANDARD:
-                break;
-            case UNIQUE:
-                buff.append("UNIQUE ");
-                break;
-            case HASH:
-                buff.append("HASH ");
-                break;
-            case UNIQUE_HASH:
-                buff.append("UNIQUE HASH ");
-                break;
-            }
-            buff.append("INDEX IF NOT EXISTS ");
-            buff.append(index.indexName);
-            buff.append(" ON ");
-            buff.append(table);
-            buff.append("(");
-            for (String col:index.columnNames) {
-                buff.appendExceptFirst(", ");
-                buff.append(col);
-            }
-            buff.append(")");
-            return buff.toString();
-        }
-
-        public void appendLimit(SQLStatement stat, long limit) {
-            stat.appendSQL(" LIMIT " + limit);
-        }
-
-        public void appendOffset(SQLStatement stat, long offset) {
-            stat.appendSQL(" OFFSET " + offset);
-        }
-
-    }
-
-}
+/*
+ * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License,
+ * Version 1.0, and under the Eclipse Public License, Version 1.0
+ * (http://h2database.com/html/license.html).
+ * Initial Developer: James Moger
+ */
+package org.h2.jaqu;
+
+import org.h2.jaqu.TableDefinition.IndexDefinition;
+import org.h2.jaqu.util.StatementBuilder;
+import org.h2.jaqu.util.StringUtils;
+
+/**
+ * This interface defines points where JaQu can build different statements
+ * depending on the database used.
+ */
+public interface SQLDialect {
+
+    /**
+     * Get the SQL snippet for the table name.
+     *
+     * @param schema the schema name, or null for no schema
+     * @param table the table name
+     * @return the SQL snippet
+     */
+    String tableName(String schema, String table);
+
+    /**
+     * Get the CREATE INDEX statement.
+     *
+     * @param schema the schema name
+     * @param table the table name
+     * @param index the index definition
+     * @return the SQL statement
+     */
+    String createIndex(String schema, String table, IndexDefinition index);
+
+    /**
+     * Append "LIMIT limit" to the SQL statement.
+     *
+     * @param stat the statement
+     * @param limit the limit
+     */
+    void appendLimit(SQLStatement stat, long limit);
+
+    /**
+     * Append "OFFSET offset" to the SQL statement.
+     *
+     * @param stat the statement
+     * @param offset the offset
+     */
+    void appendOffset(SQLStatement stat, long offset);
+
+    /**
+     *  Default implementation of an SQL dialect.
+     *  Designed for an H2 database.  May be suitable for others.
+     */
+    public static class DefaultSQLDialect implements SQLDialect {
+
+        public String tableName(String schema, String table) {
+            if (StringUtils.isNullOrEmpty(schema)) {
+                return table;
+            }
+            return schema + "." + table;
+        }
+
+        public String createIndex(String schema, String table, IndexDefinition index) {
+            StatementBuilder buff = new StatementBuilder();
+            buff.append("CREATE ");
+            switch(index.type) {
+            case STANDARD:
+                break;
+            case UNIQUE:
+                buff.append("UNIQUE ");
+                break;
+            case HASH:
+                buff.append("HASH ");
+                break;
+            case UNIQUE_HASH:
+                buff.append("UNIQUE HASH ");
+                break;
+            }
+            buff.append("INDEX IF NOT EXISTS ");
+            buff.append(index.indexName);
+            buff.append(" ON ");
+            buff.append(table);
+            buff.append("(");
+            for (String col:index.columnNames) {
+                buff.appendExceptFirst(", ");
+                buff.append(col);
+            }
+            buff.append(")");
+            return buff.toString();
+        }
+
+        public void appendLimit(SQLStatement stat, long limit) {
+            stat.appendSQL(" LIMIT " + limit);
+        }
+
+        public void appendOffset(SQLStatement stat, long offset) {
+            stat.appendSQL(" OFFSET " + offset);
+        }
+
+    }
+
+}

h2/src/tools/org/h2/jaqu/SQLStatement.java

@@ -38,7 +38,7 @@ public class SQLStatement {
         sql = null;
         return this;
     }
-    
+
     public SQLStatement appendTable(String schema, String table) {
         return appendSQL(db.getDialect().tableName(schema, table));
     }
@@ -54,7 +54,7 @@ public class SQLStatement {
         params.add(o);
         return this;
     }
-    
+
     ResultSet executeQuery() {
         try {
             return prepare(false).executeQuery();
@@ -74,7 +74,7 @@ public class SQLStatement {
             JdbcUtils.closeSilently(ps);
         }
     }
-    
+
     long executeInsert() {
         PreparedStatement ps = null;
         try {
@@ -82,9 +82,10 @@ public class SQLStatement {
             ps.executeUpdate();
             long identity = -1;
             ResultSet rs = ps.getGeneratedKeys();
-            if (rs != null && rs.next())
+            if (rs != null && rs.next()) {
                 identity = rs.getLong(1);
-            JdbcUtils.closeSilently(rs);            
+            }
+            JdbcUtils.closeSilently(rs);
             return identity;
         } catch (SQLException e) {
             throw new RuntimeException(e);
@@ -101,8 +102,8 @@ public class SQLStatement {
         }
     }
 
-    private PreparedStatement prepare(boolean returnIdentity) {
-        PreparedStatement prep = db.prepare(getSQL(), returnIdentity);
+    private PreparedStatement prepare(boolean returnGeneratedKeys) {
+        PreparedStatement prep = db.prepare(getSQL(), returnGeneratedKeys);
         for (int i = 0; i < params.size(); i++) {
             Object o = params.get(i);
             setValue(prep, i + 1, o);

h2/src/tools/org/h2/jaqu/SetColumn.java

-/*
- * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License,
- * Version 1.0, and under the Eclipse Public License, Version 1.0
- * (http://h2database.com/html/license.html).
- * Initial Developer: James Moger
- */
-package org.h2.jaqu;
-
-/**
- * This class represents "SET column = value" in an UPDATE statement.
- *
- * @param <T> the query type
- * @param <A> the new value data type
- */
-//## Java 1.5 begin ##
-public class SetColumn<T, A> implements Declaration {
-
-    private Query<T> query;
-    private A x;
-    private A y;
-
-    SetColumn(Query<T> query, A x) {
-        this.query = query;
-        this.x = x;
-    }
-
-    public Query<T> to(A y) {
-        query.addDeclarationToken(this);
-        this.y = y;
-        return query;
-    }
-
-    public void appendSQL(SQLStatement stat) {
-        query.appendSQL(stat, x);
-        stat.appendSQL("=?");
-        stat.addParameter(y);
-    }
-
-}
-//## Java 1.5 end ##
+/*
+ * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License,
+ * Version 1.0, and under the Eclipse Public License, Version 1.0
+ * (http://h2database.com/html/license.html).
+ * Initial Developer: James Moger
+ */
+package org.h2.jaqu;
+
+/**
+ * This class represents "SET column = value" in an UPDATE statement.
+ *
+ * @param <T> the query type
+ * @param <A> the new value data type
+ */
+//## Java 1.5 begin ##
+public class SetColumn<T, A> implements Declaration {
+
+    private Query<T> query;
+    private A x;
+    private A y;
+
+    SetColumn(Query<T> query, A x) {
+        this.query = query;
+        this.x = x;
+    }
+
+    public Query<T> to(A y) {
+        query.addDeclarationToken(this);
+        this.y = y;
+        return query;
+    }
+
+    public void appendSQL(SQLStatement stat) {
+        query.appendSQL(stat, x);
+        stat.appendSQL("=?");
+        stat.addParameter(y);
+    }
+
+}
+//## Java 1.5 end ##

h2/src/tools/org/h2/jaqu/Table.java

 /*
- * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License, Version
- * 1.0, and under the Eclipse Public License, Version 1.0
- * (http://h2database.com/html/license.html). Initial Developer: H2 Group
+ * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License,
+ * Version 1.0, and under the Eclipse Public License, Version 1.0
+ * (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
  */
 package org.h2.jaqu;
 
@@ -10,6 +11,9 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+/**
+ * A class that implements this interface can be used as a database table.
+ */
 /**
  * A class that implements the JaQu model mapping options.
  * <p>
@@ -112,95 +116,93 @@ import java.lang.annotation.Target;
  * <p>
  * You may automatically generate model classes as strings with the <i>Db</i>
  * and <i>DbInspector</i> objects.
- * 
+ *
  * <pre>
  * Db db = Db.open(&quot;jdbc:h2:mem:&quot;, &quot;sa&quot;, &quot;sa&quot;);
  * DbInspector inspector = new DbInspector(db);
- * List&lt;String&gt; models = inspector.generateModel(schema, table, 
- *                              packageName, annotateSchema, trimStrings);
+ * List&lt;String&gt; models =
+ *         inspector.generateModel(schema, table, packageName,
+ *         annotateSchema, trimStrings)
  * </pre>
- * 
+ *
  * OR you may use the <i>GenerateModels</i> tool to generate and save your
  * classes to the filesystem.
- * 
+ *
  * <pre>
- * java -cp h2jaqu.jar org.h2.jaqu.util.GenerateModels 
+ * java -cp h2jaqu.jar org.h2.jaqu.util.GenerateModels
  *      -url &quot;jdbc:h2:mem:&quot;
  *      -user sa -password sa -schema schemaName -table tableName
  *      -package packageName -folder destination
  *      -annotateSchema false -trimStrings true
  * </pre>
- * 
+ *
  * <b>Model Validation</b>
  * <p>
  * You may validate your model class with <i>DbInspector</i> object.<br>
- * The DbInspector will report ERRORS, WARNINGS, and SUGGESTIONS to help you.
- * 
+ * The DbInspector will report ERRORS, WARNINGS, and
+ * SUGGESTIONS to help you.
+ *
  * <pre>
- * Db db = Db.open(&quot;jdbc:h2:mem:&quot;, &quot;sa&quot;, &quot;sa&quot;);
+ * Db db = Db.open(&quot;jdbc:h2:mem:&quot;,
+ *     &quot;sa&quot;, &quot;sa&quot;);
  * DbInspector inspector = new DbInspector(db);
- * MyModel model = new MyModel();
- * List&lt;Validation&gt; remarks = inspector.validateModel(model, throwOnError);
- * for (Validation remark : remarks)
+ * List&lt;Validation&gt; remarks =
+ *     inspector.validateModel(new MyModel(), throwOnError);
+ * for (Validation remark : remarks) {
  *     System.out.println(remark);
+ * }
  * </pre>
  */
 public interface Table {
 
+    static final int reviewWholeClassAndJavadocs = 0;
+
     @Retention(RetentionPolicy.RUNTIME)
     @Target(ElementType.TYPE)
     public @interface JQDatabase {
         /**
-         * If <b>version</b> is set to a <i>non-zero</i> value, JaQu will
+         * If version is set to a non-zero value, JaQu will
          * maintain a "_jq_versions" table within your database. The
-         * <i>version</i> number will be used to call to a registered
-         * <i>DbUpgrader</i> implementation to perform relevant ALTERs or
-         * whatever.
-         * <p>
-         * <b>Default: <i>0</i></b>
-         * <p>
-         * <b>NOTE:</b><br>
-         * You must specify a <i>DbUpgrader</i> on your <i>Db</i> object to
+         * version number will be used to call to a registered
+         * DbUpgrader implementation to perform relevant ALTER statements.
+         * Default: 0.
+         * You must specify a DbUpgrader on your Db object to
          * use this parameter.
          */
         int version() default 0;
     }
-    
+
     @Retention(RetentionPolicy.RUNTIME)
     @Target(ElementType.TYPE)
     public @interface JQSchema {
         /**
-         * <b>schema</b> may be optionally specified. If it is not specified the
-         * schema will be ignored.
-         * <p>
-         * <b>Default: <i>Unspecified</i></b>
+         * The schema may be optionally specified. If it is not specified the
+         * schema will be ignored. Default: Unspecified.
          */
         String name() default "";
     }
-    
+
     /**
      * Enumeration defining the 4 index types.
-     *
      */
     public static enum IndexType {
         STANDARD, UNIQUE, HASH, UNIQUE_HASH;
     }
-    
+
     @Retention(RetentionPolicy.RUNTIME)
     @Target(ElementType.TYPE)
     public @interface JQIndex {
         /**
-         * <b>standard</b> indexes may be optionally specified. If not specified,
+         * Standard indexes may be optionally specified. If not specified,
          * these values will be ignored.
          * <ul>
          * <li>standard = "id, name"
          * <li>standard = "id name"
          * <li>standard = { "id name", "date" }
          * </ul>
-         * Standard indexes may still be added in the <i>define()</i> method if
+         * Standard indexes may still be added in the define() method if
          * the model class is not annotated with JQTable.
-         * <p>
-         * <b>Default: <i>Unspecified</i></b>
+         * Default: Unspecified.
          */
         String[] standard() default {};
 
@@ -218,7 +220,7 @@ public interface Table {
          * <b>Default: <i>Unspecified</i></b>
          */
         String[] unique() default {};
-   
+
         /**
          * <b>hash</b> indexes may be optionally specified. If not specified,
          * these values will be ignored.
@@ -232,7 +234,7 @@ public interface Table {
          * <b>Default: <i>Unspecified</i></b>
          */
         String[] hash() default {};
-   
+
         /**
          * <b>uniqueHash</b> indexes may be optionally specified. If not specified,
          * these values will be ignored.
@@ -337,8 +339,8 @@ public interface Table {
          * If <b>version</b> is set to a <i>non-zero</i> value, JaQu will
          * maintain a "_jq_versions" table within your database. The
          * <i>version</i> number will be used to call to a registered
-         * <i>DbUpgrader</i> implementation to perform relevant ALTERs or
-         * whatever.
+         * <i>DbUpgrader</i> implementation to perform relevant ALTER
+         * statements.
          * <p>
          * <b>Default: <i>0</i></b>
          * <p>

h2/src/tools/org/h2/jaqu/TableDefinition.java

@@ -227,7 +227,7 @@ class TableDefinition<T> {
 
         for (Field f : classFields) {
             // default to field name
-            String columnName = f.getName(); 
+            String columnName = f.getName();
             boolean isAutoIncrement = false;
             boolean isPrimaryKey = false;
             int maxLength = 0;

h2/src/tools/org/h2/jaqu/Validation.java

-/*
- * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License,
- * Version 1.0, and under the Eclipse Public License, Version 1.0
- * (http://h2database.com/html/license.html).
- * Initial Developer: James Moger
- */
-package org.h2.jaqu;
-
-import org.h2.jaqu.TableDefinition.FieldDefinition;
-import org.h2.jaqu.TableInspector.ColumnInspector;
-import org.h2.jaqu.util.StringUtils;
-
-/**
- * A Validation Remark is a result of running a model validation.
- * <p>
- * Each remark has a level, associated component (schema, table, column, index),
- * and a message. 
- *
- */
-public class Validation {
-
-    public static Validation CONSIDER(String table, String type, String message) {
-        return new Validation(Level.CONSIDER, table, type, message);
-    }
-
-    public static Validation CONSIDER(String table, ColumnInspector col, String message) {
-        return new Validation(Level.CONSIDER, table, col, message);
-    }
-
-    public static Validation WARN(String table, ColumnInspector col, String message) {
-        return new Validation(Level.WARN, table, col, message);
-    }
-
-    public static Validation WARN(String table, String type, String message) {
-        return new Validation(Level.WARN, table, type,  message);
-    }
-
-    public static Validation ERROR(String table, ColumnInspector col, String message) {
-        return new Validation(Level.ERROR, table, col, message);
-    }
-
-    public static Validation ERROR(String table, String type, String message) {
-        return new Validation(Level.ERROR, table, type,  message);
-    }
-
-    public static Validation ERROR(String table, FieldDefinition field, String message) {
-        return new Validation(Level.ERROR, table, field, message);
-    }
-
-    public static enum Level {
-        CONSIDER, WARN, ERROR;
-    }
-
-    Level level;
-    String table;
-    String fieldType;
-    String fieldName;
-    String message;
-
-    private Validation(Level level, String table, String type, String message) {        
-        this.level = level;
-        this.table = table;
-        this.fieldType = type;
-        this.fieldName = "";
-        this.message = message;
-    }
-
-    private Validation(Level level, String table, FieldDefinition field, String message) {        
-        this.level = level;
-        this.table = table;
-        this.fieldType = field.dataType;
-        this.fieldName = field.columnName;
-        this.message = message;
-    }
-
-    private Validation(Level level, String table, ColumnInspector col, String message) {        
-        this.level = level;
-        this.table = table;
-        this.fieldType = col.type;
-        this.fieldName = col.name;
-        this.message = message;
-    }
-
-    public Validation throwError(boolean throwOnError) {
-        if (throwOnError && isError())
-            throw new RuntimeException(toString());
-        return this;
-    }
-
-    public boolean isError() {
-        return level.equals(Level.ERROR);
-    }
-
-    public String toString() {
-        StringBuilder sb = new StringBuilder();
-        sb.append(StringUtils.pad(level.name(), 9, " ", true));
-        sb.append(StringUtils.pad(table, 25, " ", true));
-        sb.append(StringUtils.pad(fieldName, 20, " ", true));
-        sb.append(' ');
-        sb.append(message);
-        return sb.toString();
-    }
-    
-    public String toCSVString() {
-        StringBuilder sb = new StringBuilder();
-        sb.append(level.name()).append(',');
-        sb.append(table).append(',');
-        sb.append(fieldType).append(',');
-        sb.append(fieldName).append(',');
-        sb.append(message);
-        return sb.toString();
-    }
-}
+/*
+ * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License,
+ * Version 1.0, and under the Eclipse Public License, Version 1.0
+ * (http://h2database.com/html/license.html).
+ * Initial Developer: James Moger
+ */
+package org.h2.jaqu;
+
+import org.h2.jaqu.TableDefinition.FieldDefinition;
+import org.h2.jaqu.TableInspector.ColumnInspector;
+import org.h2.jaqu.util.StringUtils;
+
+/**
+ * A Validation Remark is a result of running a model validation.
+ * <p>
+ * Each remark has a level, associated component (schema, table, column, index),
+ * and a message.
+ *
+ */
+public class Validation {
+
+    private int todoReviewWholeClass;
+
+    public static Validation CONSIDER(String table, String type, String message) {
+        return new Validation(Level.CONSIDER, table, type, message);
+    }
+
+    public static Validation CONSIDER(String table, ColumnInspector col, String message) {
+        return new Validation(Level.CONSIDER, table, col, message);
+    }
+
+    public static Validation WARN(String table, ColumnInspector col, String message) {
+        return new Validation(Level.WARN, table, col, message);
+    }
+
+    public static Validation WARN(String table, String type, String message) {
+        return new Validation(Level.WARN, table, type,  message);
+    }
+
+    public static Validation ERROR(String table, ColumnInspector col, String message) {
+        return new Validation(Level.ERROR, table, col, message);
+    }
+
+    public static Validation ERROR(String table, String type, String message) {
+        return new Validation(Level.ERROR, table, type,  message);
+    }
+
+    public static Validation ERROR(String table, FieldDefinition field, String message) {
+        return new Validation(Level.ERROR, table, field, message);
+    }
+
+    public static enum Level {
+        CONSIDER, WARN, ERROR;
+    }
+
+    Level level;
+    String table;
+    String fieldType;
+    String fieldName;
+    String message;
+
+    private Validation(Level level, String table, String type, String message) {
+        this.level = level;
+        this.table = table;
+        this.fieldType = type;
+        this.fieldName = "";
+        this.message = message;
+    }
+
+    private Validation(Level level, String table, FieldDefinition field, String message) {
+        this.level = level;
+        this.table = table;
+        this.fieldType = field.dataType;
+        this.fieldName = field.columnName;
+        this.message = message;
+    }
+
+    private Validation(Level level, String table, ColumnInspector col, String message) {
+        this.level = level;
+        this.table = table;
+        this.fieldType = col.type;
+        this.fieldName = col.name;
+        this.message = message;
+    }
+
+    public Validation throwError(boolean throwOnError) {
+        if (throwOnError && isError())
+            throw new RuntimeException(toString());
+        return this;
+    }
+
+    public boolean isError() {
+        return level.equals(Level.ERROR);
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(StringUtils.pad(level.name(), 9, " ", true));
+        sb.append(StringUtils.pad(table, 25, " ", true));
+        sb.append(StringUtils.pad(fieldName, 20, " ", true));
+        sb.append(' ');
+        sb.append(message);
+        return sb.toString();
+    }
+
+    public String toCSVString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(level.name()).append(',');
+        sb.append(table).append(',');
+        sb.append(fieldType).append(',');
+        sb.append(fieldName).append(',');
+        sb.append(message);
+        return sb.toString();
+    }
+}

h2/src/tools/org/h2/jaqu/util/ClassUtils.java

@@ -13,6 +13,8 @@ package org.h2.jaqu.util;
  */
 public class ClassUtils {
 
+    int todoDelete;
+
     private ClassUtils() {
         // utility class
     }
@@ -31,5 +33,7 @@ public class ClassUtils {
             throw new RuntimeException(e);
         }
     }
+
 //## Java 1.5 end ##
+
 }

h2/src/tools/org/h2/jaqu/util/Message.java

@@ -18,6 +18,8 @@ import java.sql.SQLException;
  */
 public class Message {
 
+    private int todoDelete;
+
     private Message() {
         // utility class
     }

h2/src/tools/org/h2/jaqu/util/StatementBuilder.java

@@ -30,6 +30,8 @@ package org.h2.jaqu.util;
  */
 public class StatementBuilder {
 
+    private int todoDelete;
+
     private final StringBuilder builder = new StringBuilder();
     private int index;
 
@@ -113,11 +115,11 @@ public class StatementBuilder {
             builder.append(s);
         }
     }
-    
+
     public void append(StatementBuilder sb) {
         builder.append(sb);
     }
-    
+
     public void insert(int offset, char c) {
         builder.insert(offset, c);
     }

h2/src/tools/org/h2/jaqu/util/StatementLogger.java

-/*
- * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License,
- * Version 1.0, and under the Eclipse Public License, Version 1.0
- * (http://h2database.com/html/license.html).
- * Initial Developer: James Moger
- */
-package org.h2.jaqu.util;
-
-import java.io.PrintWriter;
-import java.text.DecimalFormat;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * Utility class to optionally log generated statements to an output stream.<br>
- * Default output stream is System.out.<br>
- * Statement logging is disabled by default.
- * <p>
- * This class also tracks the counts for generated statements by major type.
- * 
- */
-public class StatementLogger {
-    
-    public static boolean logStatements = false;
-    
-    public static PrintWriter out = new PrintWriter(System.out);
-
-    public final static AtomicLong selectCount = new AtomicLong(0);
-    
-    public final static AtomicLong createCount = new AtomicLong(0);
-    
-    public final static AtomicLong insertCount = new AtomicLong(0);
-    
-    public final static AtomicLong updateCount = new AtomicLong(0);
-    
-    public final static AtomicLong mergeCount = new AtomicLong(0);
-    
-    public final static AtomicLong deleteCount = new AtomicLong(0);
-
-    public static void create(String statement) {
-        createCount.incrementAndGet();        
-        log(statement);
-    }
-
-    public static void insert(String statement) {
-        insertCount.incrementAndGet();
-        log(statement);
-    }
-
-    public static void update(String statement) {
-        updateCount.incrementAndGet();
-        log(statement);
-    }
-    
-    public static void merge(String statement) {
-        mergeCount.incrementAndGet();
-        log(statement);
-    }
-
-    public static void delete(String statement) {
-        deleteCount.incrementAndGet();
-        log(statement);
-    }
-    
-    public static void select(String statement) {
-        selectCount.incrementAndGet();
-        log(statement);
-    }
-    
-    private static void log(String statement) {
-        if (logStatements)
-            out.println(statement);
-    }
-    
-    public static void printStats() {
-        out.println("JaQu Runtime Stats");
-        out.println("=======================");
-        printStat("CREATE", createCount);
-        printStat("INSERT", insertCount);
-        printStat("UPDATE", updateCount);
-        printStat("MERGE", mergeCount);
-        printStat("DELETE", deleteCount);
-        printStat("SELECT", selectCount);
-    }
-    
-    private static void printStat(String name, AtomicLong value) {
-        if (value.get() > 0) {
-            DecimalFormat df = new DecimalFormat("###,###,###,###");
-            out.println(name + "=" + df.format(createCount.get()));
-        }
-    }
+/*
+ * Copyright 2004-2011 H2 Group. Multiple-Licensed under the H2 License,
+ * Version 1.0, and under the Eclipse Public License, Version 1.0
+ * (http://h2database.com/html/license.html).
+ * Initial Developer: James Moger
+ */
+package org.h2.jaqu.util;
+
+import java.io.PrintWriter;
+import java.text.DecimalFormat;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Utility class to optionally log generated statements to an output stream.<br>
+ * Default output stream is System.out.<br>
+ * Statement logging is disabled by default.
+ * <p>
+ * This class also tracks the counts for generated statements by major type.
+ *
+ */
+public class StatementLogger {
+
+    public static boolean logStatements;
+    private static PrintWriter out = new PrintWriter(System.out);
+    private static final AtomicLong SELECT_COUNT = new AtomicLong();
+    private static final AtomicLong CREATE_COUNT = new AtomicLong();
+    private static final AtomicLong INSERT_COUNT = new AtomicLong();
+    private static final AtomicLong UPDATE_COUNT = new AtomicLong();
+    private static final AtomicLong MERGE_COUNT = new AtomicLong();
+    private static final AtomicLong DELETE_COUNT = new AtomicLong();
+
+    public static void create(String statement) {
+        CREATE_COUNT.incrementAndGet();
+        log(statement);
+    }
+
+    public static void insert(String statement) {
+        INSERT_COUNT.incrementAndGet();
+        log(statement);
+    }
+
+    public static void update(String statement) {
+        UPDATE_COUNT.incrementAndGet();
+        log(statement);
+    }
+
+    public static void merge(String statement) {
+        MERGE_COUNT.incrementAndGet();
+        log(statement);
+    }
+
+    public static void delete(String statement) {
+        DELETE_COUNT.incrementAndGet();
+        log(statement);
+    }
+
+    public static void select(String statement) {
+        SELECT_COUNT.incrementAndGet();
+        log(statement);
+    }
+
+    private static void log(String statement) {
+        if (logStatements) {
+            out.println(statement);
+        }
+    }
+
+    public static void printStats() {
+        out.println("JaQu Runtime Statistics");
+        out.println("=======================");
+        printStat("CREATE", CREATE_COUNT);
+        printStat("INSERT", INSERT_COUNT);
+        printStat("UPDATE", UPDATE_COUNT);
+        printStat("MERGE", MERGE_COUNT);
+        printStat("DELETE", DELETE_COUNT);
+        printStat("SELECT", SELECT_COUNT);
+    }
+
+    private static void printStat(String name, AtomicLong value) {
+        if (value.get() > 0) {
+            DecimalFormat df = new DecimalFormat("###,###,###,###");
+            out.println(name + "=" + df.format(CREATE_COUNT.get()));
+        }
+    }
+
 }
\ No newline at end of file