diff --git a/.settings/org.eclipse.jdt.ui.prefs b/.settings/org.eclipse.jdt.ui.prefs
index f37f6f0..832eb57 100644
--- a/.settings/org.eclipse.jdt.ui.prefs
+++ b/.settings/org.eclipse.jdt.ui.prefs
@@ -1,5 +1,6 @@
-#Tue Sep 02 17:00:18 PDT 2008
+#Wed Dec 23 08:08:49 PST 2009
 eclipse.preferences.version=1
+editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
 formatter_profile=_Google Format
 formatter_settings_version=11
 org.eclipse.jdt.ui.ignorelowercasenames=true
@@ -7,3 +8,54 @@
 org.eclipse.jdt.ui.ondemandthreshold=99
 org.eclipse.jdt.ui.staticondemandthreshold=99
 org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8" standalone\="no"?><templates/>
+sp_cleanup.add_default_serial_version_id=true
+sp_cleanup.add_generated_serial_version_id=false
+sp_cleanup.add_missing_annotations=false
+sp_cleanup.add_missing_deprecated_annotations=true
+sp_cleanup.add_missing_methods=false
+sp_cleanup.add_missing_nls_tags=false
+sp_cleanup.add_missing_override_annotations=true
+sp_cleanup.add_serial_version_id=false
+sp_cleanup.always_use_blocks=true
+sp_cleanup.always_use_parentheses_in_expressions=false
+sp_cleanup.always_use_this_for_non_static_field_access=false
+sp_cleanup.always_use_this_for_non_static_method_access=false
+sp_cleanup.convert_to_enhanced_for_loop=false
+sp_cleanup.correct_indentation=false
+sp_cleanup.format_source_code=false
+sp_cleanup.format_source_code_changes_only=false
+sp_cleanup.make_local_variable_final=true
+sp_cleanup.make_parameters_final=true
+sp_cleanup.make_private_fields_final=true
+sp_cleanup.make_type_abstract_if_missing_method=false
+sp_cleanup.make_variable_declarations_final=false
+sp_cleanup.never_use_blocks=false
+sp_cleanup.never_use_parentheses_in_expressions=true
+sp_cleanup.on_save_use_additional_actions=true
+sp_cleanup.organize_imports=false
+sp_cleanup.qualify_static_field_accesses_with_declaring_class=false
+sp_cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+sp_cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+sp_cleanup.qualify_static_member_accesses_with_declaring_class=false
+sp_cleanup.qualify_static_method_accesses_with_declaring_class=false
+sp_cleanup.remove_private_constructors=true
+sp_cleanup.remove_trailing_whitespaces=true
+sp_cleanup.remove_trailing_whitespaces_all=true
+sp_cleanup.remove_trailing_whitespaces_ignore_empty=false
+sp_cleanup.remove_unnecessary_casts=false
+sp_cleanup.remove_unnecessary_nls_tags=false
+sp_cleanup.remove_unused_imports=false
+sp_cleanup.remove_unused_local_variables=false
+sp_cleanup.remove_unused_private_fields=true
+sp_cleanup.remove_unused_private_members=false
+sp_cleanup.remove_unused_private_methods=true
+sp_cleanup.remove_unused_private_types=true
+sp_cleanup.sort_members=false
+sp_cleanup.sort_members_all=false
+sp_cleanup.use_blocks=false
+sp_cleanup.use_blocks_only_for_return_and_throw=false
+sp_cleanup.use_parentheses_in_expressions=false
+sp_cleanup.use_this_for_non_static_field_access=false
+sp_cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+sp_cleanup.use_this_for_non_static_method_access=false
+sp_cleanup.use_this_for_non_static_method_access_only_if_necessary=true
diff --git a/src/main/antlr/com/google/gwtorm/schema/Query.g b/src/main/antlr/com/google/gwtorm/schema/Query.g
index 4eeecd2..ce13198 100644
--- a/src/main/antlr/com/google/gwtorm/schema/Query.g
+++ b/src/main/antlr/com/google/gwtorm/schema/Query.g
@@ -80,7 +80,7 @@
         }
         return c;
       }
-      
+
       private static ColumnModel resolve(Tree node, ColumnModel model) {
         ColumnModel c;
         if (node.getType() == ID) {
@@ -190,7 +190,7 @@
  | NE
  ;
 
-field 
+field
   : n=qualifiedFieldName -> ID<Column>[(Tree)n.tree, relationModel]
   ;
 
diff --git a/src/main/java/com/google/gwtorm/client/Access.java b/src/main/java/com/google/gwtorm/client/Access.java
index 98776ee..1d7ab84 100644
--- a/src/main/java/com/google/gwtorm/client/Access.java
+++ b/src/main/java/com/google/gwtorm/client/Access.java
@@ -29,7 +29,7 @@
  * <p>
  * Applications should implement a query method using the {@link PrimaryKey}
  * annotation, for example:
- * 
+ *
  * <pre>
  * public interface FooAccess extends Access&lt;Foo, Foo.Key&gt; {
  *   &#064;PrimaryKey(&quot;key&quot;)
@@ -39,7 +39,7 @@
  *<p>
  * otherwise the primaryKey, get, update and delete operations declared by this
  * interface will be unsupported.
- * 
+ *
  * @param <T> type of the entity. Any object type is suitable, so long as at
  *        least one field uses a {@link Column} annotation.
  * @param <K> type of the primary key of entity. If the primary key is a
@@ -49,7 +49,7 @@
 public interface Access<T extends Object, K extends Key<?>> {
   /**
    * Obtain the primary key of an entity instance.
-   * 
+   *
    * @param entity the entity to get the key of; must not be null.
    * @return the primary key. Null if this entity has no primary key declared,
    *         or if the primary key does not implement the Key interface.
@@ -58,7 +58,7 @@
 
   /**
    * Convert a collection of objects into a map, keyed by their primary key.
-   * 
+   *
    * @param c the collection
    * @return a map of the objects, indexed by their primary key.
    */
@@ -70,7 +70,7 @@
    * This method is only implemented if the entity's primary key is defined to
    * be an implementation of the {@link Key} interface. Otherwise the method
    * throws {@link UnsupportedOperationException}.
-   * 
+   *
    * @param key the primary key instance; must not be null.
    * @return the entity; null if no entity has this key.
    * @throws OrmException the data lookup failed.
@@ -87,7 +87,7 @@
    * <p>
    * This method is a batch form of {@link #get(Key)} and may be optimized to
    * reduce round-trips to the data store.
-   * 
+   *
    * @param keys collection of zero or more keys to perform lookup with.
    * @return collection of all matching entities; this may be a smaller result
    *         than the keys supplied if one or more of the keys does not match an
@@ -99,7 +99,7 @@
 
   /**
    * Immediately insert new entities into the data store.
-   * 
+   *
    * @param instances the instances to insert. The iteration occurs only once.
    * @throws OrmException data insertion failed.
    */
@@ -107,7 +107,7 @@
 
   /**
    * Insert new entities into the data store.
-   * 
+   *
    * @param instances the instances to insert. The iteration occurs only once.
    * @param txn transaction to batch the operation into. If not null the data
    *        store changes will be delayed to {@link Transaction#commit()} is
@@ -118,7 +118,7 @@
 
   /**
    * Immediately update existing entities in the data store.
-   * 
+   *
    * @param instances the instances to update. The iteration occurs only once.
    * @throws OrmException data modification failed.
    * @throws UnsupportedOperationException no PrimaryKey was declared.
@@ -127,7 +127,7 @@
 
   /**
    * Update existing entities in the data store.
-   * 
+   *
    * @param instances the instances to update. The iteration occurs only once.
    * @param txn transaction to batch the operation into. If not null the data
    *        store changes will be delayed to {@link Transaction#commit()} is
@@ -139,7 +139,7 @@
 
   /**
    * Immediately delete existing entities from the data store.
-   * 
+   *
    * @param instances the instances to delete. The iteration occurs only once.
    * @throws OrmException data removal failed.
    * @throws UnsupportedOperationException no PrimaryKey was declared.
@@ -148,7 +148,7 @@
 
   /**
    * Delete existing entities from the data store.
-   * 
+   *
    * @param instances the instances to delete. The iteration occurs only once.
    * @param txn transaction to batch the operation into. If not null the data
    *        store changes will be delayed to {@link Transaction#commit()} is
diff --git a/src/main/java/com/google/gwtorm/client/CompoundKey.java b/src/main/java/com/google/gwtorm/client/CompoundKey.java
index f64114a..ac6572e 100644
--- a/src/main/java/com/google/gwtorm/client/CompoundKey.java
+++ b/src/main/java/com/google/gwtorm/client/CompoundKey.java
@@ -21,7 +21,7 @@
  * <p>
  * Applications should subclass this type to create their own entity-specific
  * key classes.
- * 
+ *
  * @param <P> the parent key type. Use {@link Key} if no parent key is needed.
  */
 public abstract class CompoundKey<P extends Key<?>> implements Key<P>,
diff --git a/src/main/java/com/google/gwtorm/client/IntKey.java b/src/main/java/com/google/gwtorm/client/IntKey.java
index 883ca3d..7ed8bb9 100644
--- a/src/main/java/com/google/gwtorm/client/IntKey.java
+++ b/src/main/java/com/google/gwtorm/client/IntKey.java
@@ -21,7 +21,7 @@
  * <p>
  * Applications should subclass this type to create their own entity-specific
  * key classes.
- * 
+ *
  * @param <P> the parent key type. Use {@link Key} if no parent key is needed.
  */
 public abstract class IntKey<P extends Key<?>> implements Key<P>, Serializable {
diff --git a/src/main/java/com/google/gwtorm/client/Key.java b/src/main/java/com/google/gwtorm/client/Key.java
index 504b358..a08929a 100644
--- a/src/main/java/com/google/gwtorm/client/Key.java
+++ b/src/main/java/com/google/gwtorm/client/Key.java
@@ -20,13 +20,13 @@
  * Although not required, entities should make their primary key type implement
  * this interface, permitting traversal up through the containment hierarchy of
  * the entity keys.
- * 
+ *
  * @param <P> type of the parent key. If no parent, use {@link Key} itself.
  */
 public interface Key<P extends Key<?>> {
   /**
    * Get the parent key instance.
-   * 
+   *
    * @return the parent key; null if this entity key is a root-level key.
    */
   public P getParentKey();
diff --git a/src/main/java/com/google/gwtorm/client/KeyUtil.java b/src/main/java/com/google/gwtorm/client/KeyUtil.java
index caab29b..938dac6 100644
--- a/src/main/java/com/google/gwtorm/client/KeyUtil.java
+++ b/src/main/java/com/google/gwtorm/client/KeyUtil.java
@@ -42,7 +42,7 @@
 
   /**
    * Determine if two keys are equal, supporting null references.
-   * 
+   *
    * @param <T> type of the key entity.
    * @param a first key to test; may be null.
    * @param b second key to test; may be null.
@@ -66,7 +66,7 @@
    * escapes (e.g. ' ' is '+' and '%' is '%25'). The special character '/' is
    * left literal. The comma character (',') is always encoded, permitting
    * multiple encoded string values to be joined together safely.
-   * 
+   *
    * @param e the string to encode, must not be null.
    * @return the encoded string.
    */
@@ -76,7 +76,7 @@
 
   /**
    * Decode a string previously encoded by {@link #encode(String)}.
-   * 
+   *
    * @param e the string to decode, must not be null.
    * @return the decoded string.
    */
@@ -86,7 +86,7 @@
 
   /**
    * Split a string along the last comma and parse into the parent.
-   * 
+   *
    * @param parent parent key; <code>parent.fromString(in[0..comma])</code>.
    * @param in the input string.
    * @return text (if any) after the last comma in the input.
diff --git a/src/main/java/com/google/gwtorm/client/LongKey.java b/src/main/java/com/google/gwtorm/client/LongKey.java
index c249e87..33a4367 100644
--- a/src/main/java/com/google/gwtorm/client/LongKey.java
+++ b/src/main/java/com/google/gwtorm/client/LongKey.java
@@ -21,7 +21,7 @@
  * <p>
  * Applications should subclass this type to create their own entity-specific
  * key classes.
- * 
+ *
  * @param <P> the parent key type. Use {@link Key} if no parent key is needed.
  */
 public abstract class LongKey<P extends Key<?>> implements Key<P>, Serializable {
diff --git a/src/main/java/com/google/gwtorm/client/OrmRunnable.java b/src/main/java/com/google/gwtorm/client/OrmRunnable.java
index 5083928..4db3f51 100644
--- a/src/main/java/com/google/gwtorm/client/OrmRunnable.java
+++ b/src/main/java/com/google/gwtorm/client/OrmRunnable.java
@@ -19,7 +19,7 @@
  * <p>
  * The {@link Schema} is free to invoke this runnable multiple times if an
  * {@link OrmConcurrencyException} is thrown by the run method.
- * 
+ *
  * @param <T> type of object the run method returns.
  * @param <S> type of schema the run method needs to perform its work.
  */
@@ -31,7 +31,7 @@
    * ensure they are looking at the most current copy of the data from the
    * database. If a method is invoked a second time to recover from a
    * concurrency error it would need to read the data again.
-   * 
+   *
    * @param db active schema handle to query through, and make updates on.
    * @param txn the current transaction handle. Commit is invoked by the caller.
    * @param retry true if this is not the first attempt to execute this task.
diff --git a/src/main/java/com/google/gwtorm/client/PrimaryKey.java b/src/main/java/com/google/gwtorm/client/PrimaryKey.java
index b1308f4..922b684 100644
--- a/src/main/java/com/google/gwtorm/client/PrimaryKey.java
+++ b/src/main/java/com/google/gwtorm/client/PrimaryKey.java
@@ -21,7 +21,7 @@
 
 /**
  * Annotation marking a query function in a {@link Access} interface as the key.
- * 
+ *
  * @see Access
  */
 @Retention(RetentionPolicy.RUNTIME)
diff --git a/src/main/java/com/google/gwtorm/client/Query.java b/src/main/java/com/google/gwtorm/client/Query.java
index 19359f6..6e7bc9a 100644
--- a/src/main/java/com/google/gwtorm/client/Query.java
+++ b/src/main/java/com/google/gwtorm/client/Query.java
@@ -23,7 +23,7 @@
  * Annotation marking a method in an {@link Access} interface as a query.
  * <p>
  * Query methods must return a parameterized {@link ResultSet}, for example:
- * 
+ *
  * <pre>
  * public interface FooAccess extends Access&lt;Foo, Foo.Key&gt; {
  *   &#064;Query(&quot;WHERE a=?&quot;)
@@ -32,12 +32,12 @@
  *</pre>
  *<p>
  * Query strings must conform to the following grammar:
- * 
+ *
  * <pre>
  * [WHERE &lt;condition&gt; [AND &lt;condition&gt; ...]]
  * [ORDER BY &lt;property&gt; [ASC | DESC] [, &lt;property&gt; [ASC | DESC] ...]]
  * [LIMIT { &lt;count&gt; | ? }]
- * 
+ *
  * &lt;condition&gt; := &lt;property&gt; { &lt; | &lt;= | &gt; | &gt;= | = | != } &lt;value&gt;
  * &lt;value&gt; := { ? | true | false | &lt;int&gt; | &lt;string&gt; }
  * </pre>
diff --git a/src/main/java/com/google/gwtorm/client/Relation.java b/src/main/java/com/google/gwtorm/client/Relation.java
index a43a033..97b895e 100644
--- a/src/main/java/com/google/gwtorm/client/Relation.java
+++ b/src/main/java/com/google/gwtorm/client/Relation.java
@@ -24,11 +24,11 @@
  * <p>
  * Access methods must return an interface extending {@link Access}, for
  * example:
- * 
+ *
  * <pre>
  * public interface FooAccess extends Access&lt;Foo, Foo.Key&gt; {
  * }
- * 
+ *
  * public interface BarSchema extends Schema {
  *   &#064;Relation
  *   FooAccess foos();
diff --git a/src/main/java/com/google/gwtorm/client/ResultSet.java b/src/main/java/com/google/gwtorm/client/ResultSet.java
index c8c392b..4a39dd1 100644
--- a/src/main/java/com/google/gwtorm/client/ResultSet.java
+++ b/src/main/java/com/google/gwtorm/client/ResultSet.java
@@ -19,7 +19,7 @@
 
 /**
  * Result from any data store query function.
- * 
+ *
  * @param <T> type of entity being returned by the query.
  */
 public interface ResultSet<T> extends Iterable<T> {
@@ -37,7 +37,7 @@
    * <p>
    * Prior to returning {@link #close()} is invoked. This method must not be
    * combined with {@link #iterator()} on the same instance.
-   * 
+   *
    * @return list of the complete results.
    */
   List<T> toList();
diff --git a/src/main/java/com/google/gwtorm/client/Schema.java b/src/main/java/com/google/gwtorm/client/Schema.java
index 84d52d5..13def7c 100644
--- a/src/main/java/com/google/gwtorm/client/Schema.java
+++ b/src/main/java/com/google/gwtorm/client/Schema.java
@@ -39,17 +39,16 @@
  * <p>
  * For example the OurDb schema creates two tables (identical structure) named
  * <code>someFoos</code> and <code>otherFoos</code>:
- * 
+ *
  * <pre>
  * public interface FooAccess extends Access&lt;Foo, Foo.Key&gt; {
  *   &#064;PrimaryKey(&quot;key&quot;)
  *   Foo byKey(Foo.Key k) throws OrmException;
  * }
- * 
  * public interface OurDb extends Schema {
  *   &#064;Relation
  *   FooAccess someFoos();
- * 
+ *
  *   &#064;Relation
  *   FooAccess otherFoos();
  * }
@@ -58,7 +57,7 @@
 public interface Schema {
   /**
    * Automatically create the database tables.
-   * 
+   *
    * @throws OrmException tables already exist or create permission is denied.
    */
   void createSchema() throws OrmException;
@@ -69,7 +68,7 @@
    * Only one transaction can be in-flight at a time on any given Schema
    * instance. Applications must commit or rollback a previously created
    * transaction before beginning another transaction on the same Schema.
-   * 
+   *
    * @return the new transaction.
    * @throws OrmException the schema has been closed or another transaction has
    *         already been begun on this schema instance.
@@ -78,7 +77,7 @@
 
   /**
    * Execute a task within a transaction, restarting it if necessary.
-   * 
+   *
    * @param <T> type of return value for the task.
    * @param <S> type of <code>this</code>.
    * @param task the task to execute.
diff --git a/src/main/java/com/google/gwtorm/client/SchemaFactory.java b/src/main/java/com/google/gwtorm/client/SchemaFactory.java
index f754734..21419e9 100644
--- a/src/main/java/com/google/gwtorm/client/SchemaFactory.java
+++ b/src/main/java/com/google/gwtorm/client/SchemaFactory.java
@@ -16,13 +16,13 @@
 
 /**
  * Creates new application Schema instances on demand.
- * 
+ *
  * @param <S> schema type which defines the application database's.
  */
 public interface SchemaFactory<S extends Schema> {
   /**
    * Open a new connection to the database and get a Schema wrapper.
-   * 
+   *
    * @return a new connection, wrapped up in the application's Schema.
    * @throws OrmException the connection could not be opened to the database.
    *         The exception detail should be examined to determine the root cause
diff --git a/src/main/java/com/google/gwtorm/client/SecondaryKey.java b/src/main/java/com/google/gwtorm/client/SecondaryKey.java
index 222087b..773bc1a 100644
--- a/src/main/java/com/google/gwtorm/client/SecondaryKey.java
+++ b/src/main/java/com/google/gwtorm/client/SecondaryKey.java
@@ -23,7 +23,7 @@
  * Annotation marking a query function in a {@link Access} interface as a key.
  * <p>
  * SecondaryKey is gwtorm's concept of SQL UNIQUE.
- * 
+ *
  * @see Access
  */
 @Retention(RetentionPolicy.RUNTIME)
diff --git a/src/main/java/com/google/gwtorm/client/Sequence.java b/src/main/java/com/google/gwtorm/client/Sequence.java
index 2971fc9..6084fa5 100644
--- a/src/main/java/com/google/gwtorm/client/Sequence.java
+++ b/src/main/java/com/google/gwtorm/client/Sequence.java
@@ -24,7 +24,7 @@
  * <p>
  * Sequence methods must return a primitive <code>int</code> or
  * <code>long</code> type.
- * 
+ *
  * <pre>
  * public interface BarSchema extends Schema {
  *   &#064;Sequence
diff --git a/src/main/java/com/google/gwtorm/client/ShortKey.java b/src/main/java/com/google/gwtorm/client/ShortKey.java
index b004170..3f666f9 100644
--- a/src/main/java/com/google/gwtorm/client/ShortKey.java
+++ b/src/main/java/com/google/gwtorm/client/ShortKey.java
@@ -21,7 +21,7 @@
  * <p>
  * Applications should subclass this type to create their own entity-specific
  * key classes.
- * 
+ *
  * @param <P> the parent key type. Use {@link Key} if no parent key is needed.
  */
 public abstract class ShortKey<P extends Key<?>> implements Key<P>,
diff --git a/src/main/java/com/google/gwtorm/client/StringKey.java b/src/main/java/com/google/gwtorm/client/StringKey.java
index 0ba70c4..2ccd2f9 100644
--- a/src/main/java/com/google/gwtorm/client/StringKey.java
+++ b/src/main/java/com/google/gwtorm/client/StringKey.java
@@ -21,7 +21,7 @@
  * <p>
  * Applications should subclass this type to create their own entity-specific
  * key classes.
- * 
+ *
  * @param <P> the parent key type. Use {@link Key} if no parent key is needed.
  */
 public abstract class StringKey<P extends Key<?>> implements Key<P>,
diff --git a/src/main/java/com/google/gwtorm/client/Transaction.java b/src/main/java/com/google/gwtorm/client/Transaction.java
index 8f2963b..0780ab4 100644
--- a/src/main/java/com/google/gwtorm/client/Transaction.java
+++ b/src/main/java/com/google/gwtorm/client/Transaction.java
@@ -26,13 +26,13 @@
  * <li>{@link Access#update(Iterable, Transaction)}</li>
  * <li>{@link Access#delete(Iterable, Transaction)}</li>
  * <ul>
- * 
+ *
  * @see Schema#beginTransaction()
  */
 public interface Transaction {
   /**
    * Commit this transaction, finishing all actions.
-   * 
+   *
    * @throws OrmException data store refused/rejected one or more actions.
    */
   void commit() throws OrmException;
@@ -41,7 +41,7 @@
    * Rollback (abort) this transaction, performing none of the actions.
    * <p>
    * This method has no affect if the transaction has not made any changes.
-   * 
+   *
    * @throws OrmException data store couldn't undo the transaction, as it is
    *         already committed.
    */
diff --git a/src/main/java/com/google/gwtorm/jdbc/AbstractSchemaFactory.java b/src/main/java/com/google/gwtorm/jdbc/AbstractSchemaFactory.java
index d087a72..2db0290 100644
--- a/src/main/java/com/google/gwtorm/jdbc/AbstractSchemaFactory.java
+++ b/src/main/java/com/google/gwtorm/jdbc/AbstractSchemaFactory.java
@@ -24,13 +24,13 @@
  * Applications should not use this interface. It is automatically implemented
  * at runtime to provide fast construction for new Schema instances within
  * {@link Database#open()}.
- * 
+ *
  * @param <T> type of the application schema.
  */
 public abstract class AbstractSchemaFactory<T extends Schema> {
   /**
    * Create a new schema instance.
-   * 
+   *
    * @param db the database instance which created the connection.
    * @param c the JDBC connection the instance will talk to the database on.
    * @return the new schema instance, wrapping the connection.
diff --git a/src/main/java/com/google/gwtorm/jdbc/Database.java b/src/main/java/com/google/gwtorm/jdbc/Database.java
index 553dde3..869d200 100644
--- a/src/main/java/com/google/gwtorm/jdbc/Database.java
+++ b/src/main/java/com/google/gwtorm/jdbc/Database.java
@@ -49,7 +49,7 @@
  * the application.
  * <p>
  * Database instances are thread-safe, but returned Schema instances are not.
- * 
+ *
  * @param <T>
  */
 public class Database<T extends Schema> implements SchemaFactory<T> {
@@ -67,7 +67,7 @@
 
   /**
    * Create a new database interface, generating the interface implementations.
-   * 
+   *
    * @param ds JDBC connection information
    * @param schema application extension of the Schema interface to implement.
    * @throws OrmException the schema interface is incorrectly defined, or the
@@ -145,7 +145,7 @@
 
   /**
    * Open a new connection to the database and get a Schema wrapper.
-   * 
+   *
    * @return a new JDBC connection, wrapped up in the application's Schema.
    * @throws OrmException the connection could not be opened to the database.
    *         The JDBC exception detail should be examined to determine the root
diff --git a/src/main/java/com/google/gwtorm/jdbc/SimpleDataSource.java b/src/main/java/com/google/gwtorm/jdbc/SimpleDataSource.java
index fe24ce9..ab5a9d9 100644
--- a/src/main/java/com/google/gwtorm/jdbc/SimpleDataSource.java
+++ b/src/main/java/com/google/gwtorm/jdbc/SimpleDataSource.java
@@ -42,7 +42,7 @@
    * The JDBC properties information must define at least <code>url</code> and
    * <code>driver</code>, but may also include driver specific properties such
    * as <code>username</code> and <code>password</code>.
-   * 
+   *
    * @param dbInfo JDBC connection information. The property table is copied.
    * @throws SQLException the driver class is not available through the current
    *         class loader.
diff --git a/src/main/java/com/google/gwtorm/schema/sql/SqlDialect.java b/src/main/java/com/google/gwtorm/schema/sql/SqlDialect.java
index 8fa1cf3..7a8d243 100644
--- a/src/main/java/com/google/gwtorm/schema/sql/SqlDialect.java
+++ b/src/main/java/com/google/gwtorm/schema/sql/SqlDialect.java
@@ -104,7 +104,7 @@
 
   /**
    * Convert a driver specific exception into an {@link OrmException}.
-   * 
+   *
    * @param op short description of the operation, e.g. "update" or "fetch".
    * @param entity name of the entity being accessed by the operation.
    * @param err the driver specific exception.
@@ -165,7 +165,7 @@
 
   /**
    * Append driver specific storage parameters to a CREATE TABLE statement.
-   * 
+   *
    * @param sqlBuffer buffer holding the CREATE TABLE, just after the closing
    *        parenthesis after the column list.
    * @param relationModel the model of the table being generated.
