Coverage Report

Coverage Report - org.apache.torque.engine.database.model.Table

Classes in this File
Line Coverage
Branch Coverage
Complexity
Table
0/285
0/126
1.905
 package org.apache.torque.engine.database.model;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE
  * file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
  * License. You may obtain a copy of the License at
  * 
  * http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
  * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations under the License.
  */
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Hashtable;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
 import org.apache.commons.collections.map.ListOrderedMap;
 import org.apache.commons.lang.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.torque.engine.EngineException;
 import org.xml.sax.Attributes;
 
 /**
  * Data about a table used in an application.
  * 
  * @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>
  * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
  * @author <a href="mailto:mpoeschl@marmot.at>Martin Poeschl</a>
  * @author <a href="mailto:jmcnally@collab.net>John McNally</a>
  * @author <a href="mailto:dlr@collab.net>Daniel Rall</a>
  * @author <a href="mailto:byron_foster@byron_foster@yahoo.com>Byron Foster</a>
  * @author <a href="mailto:monroe@dukece.com>Greg Monroe</a>
  * @version $Id: Table.java,v 1.1 2007-10-21 07:57:27 abyrne Exp $
  */
 public class Table implements IDMethod {
     /** Logging class from commons.logging */
     private static Log log = LogFactory.getLog(Table.class);
 
     // private AttributeListImpl attributes;
     private List columnList;
     private List foreignKeys;
     private List indices;
     private List unices;
     private List idMethodParameters;
     private String name;
     private String description;
     private String javaName;
     private String idMethod;
     private String javaNamingMethod;
     private Database tableParent;
     private List referrers;
     private List foreignTableNames;
     private boolean containsForeignPK;
     private Column inheritanceColumn;
     private boolean skipSql;
     private boolean abstractValue;
     private String alias;
     private String enterface;
     private String pkg;
     private String baseClass;
     private String basePeer;
     private Hashtable columnsByName;
     private Hashtable columnsByJavaName;
     private boolean needsTransactionInPostgres;
     private boolean heavyIndexing;
     private boolean forReferenceOnly;
     private Map options;
 
     /**
      * Default Constructor
      */
     public Table() {
         this(null);
     }
 
     /**
      * Constructs a table object with a name
      * 
      * @param name
      *            table name
      */
     public Table(String name) {
         this.name = name;
         columnList = new ArrayList();
         foreignKeys = new ArrayList(5);
         indices = new ArrayList(5);
         unices = new ArrayList(5);
         columnsByName = new Hashtable();
         columnsByJavaName = new Hashtable();
         options = Collections.synchronizedMap(new ListOrderedMap());
     }
 
     /**
      * Load the table object from an xml tag.
      * 
      * @param attrib
      *            xml attributes
      * @param defaultIdMethod
      *            defined at db level
      */
     public void loadFromXML(Attributes attrib, String defaultIdMethod) {
         name = attrib.getValue("name");
         javaName = attrib.getValue("javaName");
         idMethod = attrib.getValue("idMethod");
 
         // retrieves the method for converting from specified name to
         // a java name.
         javaNamingMethod = attrib.getValue("javaNamingMethod");
         if (javaNamingMethod == null) {
             javaNamingMethod = getDatabase().getDefaultJavaNamingMethod();
         }
 
         if ("null".equals(idMethod)) {
             idMethod = defaultIdMethod;
         }
         skipSql = "true".equals(attrib.getValue("skipSql"));
         // pkg = attrib.getValue("package");
         abstractValue = "true".equals(attrib.getValue("abstract"));
         baseClass = attrib.getValue("baseClass");
         basePeer = attrib.getValue("basePeer");
         alias = attrib.getValue("alias");
         heavyIndexing = "true".equals(attrib.getValue("heavyIndexing"))
                 || (!"false".equals(attrib.getValue("heavyIndexing")) && getDatabase().isHeavyIndexing());
         description = attrib.getValue("description");
         enterface = attrib.getValue("interface");
     }
 
     /**
      * <p>
      * A hook for the SAX XML parser to call when this table has been fully loaded from the XML, and all nested elements
      * have been processed.
      * </p>
      * 
      * <p>
      * Performs heavy indexing and naming of elements which weren't provided with a name.
      * </p>
      */
     public void doFinalInitialization() {
         // Heavy indexing must wait until after all columns composing
         // a table's primary key have been parsed.
         if (heavyIndexing) {
             doHeavyIndexing();
         }
 
         // Name any indices which are missing a name using the
         // appropriate algorithm.
         doNaming();
     }
 
     /**
      * <p>
      * Adds extra indices for multi-part primary key columns.
      * </p>
      * 
      * <p>
      * For databases like MySQL, values in a where clause must match key part order from the left to right. So, in the
      * key definition <code>PRIMARY KEY (FOO_ID, BAR_ID)</code>, <code>FOO_ID</code> <i>must</i> be the first element
      * used in the <code>where</code> clause of the SQL query used against this table for the primary key index to be
      * used. This feature could cause problems under MySQL with heavily indexed tables, as MySQL currently only supports
      * 16 indices per table (i.e. it might cause too many indices to be created).
      * </p>
      * 
      * <p>
      * See <a href="http://www.mysql.com/doc/E/X/EXPLAIN.html">the manual</a> for a better description of why heavy
      * indexing is useful for quickly searchable database tables.
      * </p>
      */
     private void doHeavyIndexing() {
         if (log.isDebugEnabled()) {
             log.debug("doHeavyIndex() called on table " + name);
         }
 
         List pk = getPrimaryKey();
         int size = pk.size();
 
         try {
             // We start at an offset of 1 because the entire column
             // list is generally implicitly indexed by the fact that
             // it's a primary key.
             for (int i = 1; i < size; i++) {
                 addIndex(new Index(this, pk.subList(i, size)));
             }
         } catch (EngineException e) {
             log.error(e, e);
         }
     }
 
     /**
      * Names composing objects which haven't yet been named. This currently consists of foreign-key and index entities.
      */
     private void doNaming() {
         int i;
         int size;
         String name;
 
         // Assure names are unique across all databases.
         try {
             for (i = 0, size = foreignKeys.size(); i < size; i++) {
                 ForeignKey fk = (ForeignKey) foreignKeys.get(i);
                 name = fk.getName();
                 if (StringUtils.isEmpty(name)) {
                     name = acquireConstraintName("FK", i + 1);
                     fk.setName(name);
                 }
             }
 
             for (i = 0, size = indices.size(); i < size; i++) {
                 Index index = (Index) indices.get(i);
                 name = index.getName();
                 if (StringUtils.isEmpty(name)) {
                     name = acquireConstraintName("I", i + 1);
                     index.setName(name);
                 }
             }
 
             for (i = 0, size = unices.size(); i < size; i++) {
                 Unique unique = (Unique) unices.get(i);
                 name = unique.getName();
                 if (StringUtils.isEmpty(name)) {
                     name = acquireConstraintName("U", i + 1);
                     unique.setName(name);
                 }
             }
         } catch (EngineException nameAlreadyInUse) {
             log.error(nameAlreadyInUse, nameAlreadyInUse);
         }
     }
 
     /**
      * Macro to a constraint name.
      * 
      * @param nameType
      *            constraint type
      * @param nbr
      *            unique number for this constraint type
      * @return unique name for constraint
      * @throws EngineException
      */
     private final String acquireConstraintName(String nameType, int nbr) throws EngineException {
         List inputs = new ArrayList(4);
         inputs.add(getDatabase());
         inputs.add(getName());
         inputs.add(nameType);
         inputs.add(new Integer(nbr));
         return NameFactory.generateName(NameFactory.CONSTRAINT_GENERATOR, inputs);
     }
 
     /**
      * Gets the value of base class for classes produced from this table.
      * 
      * @return The base class for classes produced from this table.
      */
     public String getBaseClass() {
         if (isAlias() && baseClass == null) {
             return alias;
         } else if (baseClass == null) {
             return getDatabase().getBaseClass();
         } else {
             return baseClass;
         }
     }
 
     /**
      * Set the value of baseClass.
      * 
      * @param v
      *            Value to assign to baseClass.
      */
     public void setBaseClass(String v) {
         this.baseClass = v;
     }
 
     /**
      * Get the value of basePeer.
      * 
      * @return value of basePeer.
      */
     public String getBasePeer() {
         if (isAlias() && basePeer == null) {
             return alias + "Peer";
         } else if (basePeer == null) {
             return getDatabase().getBasePeer();
         } else {
             return basePeer;
         }
     }
 
     /**
      * Set the value of basePeer.
      * 
      * @param v
      *            Value to assign to basePeer.
      */
     public void setBasePeer(String v) {
         this.basePeer = v;
     }
 
     /**
      * A utility function to create a new column from attrib and add it to this table.
      * 
      * @param attrib
      *            xml attributes for the column to add
      * @return the added column
      */
     public Column addColumn(Attributes attrib) {
         Column col = new Column();
         col.setTable(this);
         col.setCorrectGetters(false);
         col.loadFromXML(attrib);
         addColumn(col);
         return col;
     }
 
     /**
      * Adds a new column to the column list and set the parent table of the column to the current table
      * 
      * @param col
      *            the column to add
      */
     public void addColumn(Column col) {
         col.setTable(this);
         if (col.isInheritance()) {
             inheritanceColumn = col;
         }
         columnList.add(col);
         columnsByName.put(col.getName(), col);
         columnsByJavaName.put(col.getJavaName(), col);
         col.setPosition(columnList.size());
         needsTransactionInPostgres |= col.requiresTransactionInPostgres();
     }
 
     /**
      * A utility function to create a new foreign key from attrib and add it to this table.
      * 
      * @param attrib
      *            the xml attributes
      * @return the created ForeignKey
      */
     public ForeignKey addForeignKey(Attributes attrib) {
         ForeignKey fk = new ForeignKey();
         fk.loadFromXML(attrib);
         addForeignKey(fk);
         return fk;
     }
 
     /**
      * Gets the column that subclasses of the class representing this table can be produced from.
      */
     public Column getChildrenColumn() {
         return inheritanceColumn;
     }
 
     /**
      * Get the objects that can be created from this table.
      */
     public List getChildrenNames() {
         if (inheritanceColumn == null || !inheritanceColumn.isEnumeratedClasses()) {
             return null;
         }
         List children = inheritanceColumn.getChildren();
         List names = new ArrayList(children.size());
         for (int i = 0; i < children.size(); i++) {
             names.add(((Inheritance) children.get(i)).getClassName());
         }
         return names;
     }
 
     /**
      * Adds the foreign key from another table that refers to this table.
      * 
      * @param fk
      *            A foreign key refering to this table
      */
     public void addReferrer(ForeignKey fk) {
         if (referrers == null) {
             referrers = new ArrayList(5);
         }
         referrers.add(fk);
     }
 
     /**
      * Get list of references to this table.
      * 
      * @return A list of references to this table
      */
     public List getReferrers() {
         return referrers;
     }
 
     /**
      * Set whether this table contains a foreign PK
      * 
      * @param b
      */
     public void setContainsForeignPK(boolean b) {
         containsForeignPK = b;
     }
 
     /**
      * Determine if this table contains a foreign PK
      */
     public boolean getContainsForeignPK() {
         return containsForeignPK;
     }
 
     /**
      * A list of tables referenced by foreign keys in this table
      * 
      * @return A list of tables
      */
     public List getForeignTableNames() {
         if (foreignTableNames == null) {
             foreignTableNames = new ArrayList(1);
         }
         return foreignTableNames;
     }
 
     /**
      * Adds a new FK to the FK list and set the parent table of the column to the current table
      * 
      * @param fk
      *            A foreign key
      */
     public void addForeignKey(ForeignKey fk) {
         fk.setTable(this);
         foreignKeys.add(fk);
 
         if (foreignTableNames == null) {
             foreignTableNames = new ArrayList(5);
         }
         if (!foreignTableNames.contains(fk.getForeignTableName())) {
             foreignTableNames.add(fk.getForeignTableName());
         }
     }
 
     /**
      * Return true if the column requires a transaction in Postgres
      */
     public boolean requiresTransactionInPostgres() {
         return needsTransactionInPostgres;
     }
 
     /**
      * A utility function to create a new id method parameter from attrib and add it to this table.
      */
     public IdMethodParameter addIdMethodParameter(Attributes attrib) {
         IdMethodParameter imp = new IdMethodParameter();
         imp.loadFromXML(attrib);
         addIdMethodParameter(imp);
         return imp;
     }
 
     /**
      * Adds a new ID method parameter to the list and sets the parent table of the column associated with the supplied
      * parameter to this table.
      * 
      * @param imp
      *            The column to add as an ID method parameter.
      */
     public void addIdMethodParameter(IdMethodParameter imp) {
         imp.setTable(this);
         if (idMethodParameters == null) {
             idMethodParameters = new ArrayList(2);
         }
         idMethodParameters.add(imp);
     }
 
     /**
      * Adds a new index to the index list and set the parent table of the column to the current table
      */
     public void addIndex(Index index) {
         index.setTable(this);
         indices.add(index);
     }
 
     /**
      * A utility function to create a new index from attrib and add it to this table.
      */
     public Index addIndex(Attributes attrib) {
         Index index = new Index();
         index.loadFromXML(attrib);
         addIndex(index);
         return index;
     }
 
     /**
      * Adds a new Unique to the Unique list and set the parent table of the column to the current table
      */
     public void addUnique(Unique unique) {
         unique.setTable(this);
         unices.add(unique);
     }
 
     /**
      * A utility function to create a new Unique from attrib and add it to this table.
      * 
      * @param attrib
      *            the xml attributes
      */
     public Unique addUnique(Attributes attrib) {
         Unique unique = new Unique();
         unique.loadFromXML(attrib);
         addUnique(unique);
         return unique;
     }
 
     /**
      * Get the name of the Table
      */
     public String getName() {
         return name;
     }
 
     /**
      * Set the name of the Table
      */
     public void setName(String newName) {
         name = newName;
     }
 
     /**
      * Get the description for the Table
      */
     public String getDescription() {
         return description;
     }
 
     /**
      * Set the description for the Table
      * 
      * @param newDescription
      *            description for the Table
      */
     public void setDescription(String newDescription) {
         description = newDescription;
     }
 
     /**
      * Get name to use in Java sources
      */
     public String getJavaName() {
         if (javaName == null) {
             List inputs = new ArrayList(2);
             inputs.add(name);
             inputs.add(javaNamingMethod);
             try {
                 javaName = NameFactory.generateName(NameFactory.JAVA_GENERATOR, inputs);
             } catch (EngineException e) {
                 log.error(e, e);
             }
         }
         return javaName;
     }
 
     /**
      * Set name to use in Java sources
      */
     public void setJavaName(String javaName) {
         this.javaName = javaName;
     }
 
     /**
      * Get the method for generating pk's
      */
     public String getIdMethod() {
         if (idMethod == null) {
             return IDMethod.NO_ID_METHOD;
         } else {
             return idMethod;
         }
     }
 
     /**
      * Set the method for generating pk's
      */
     public void setIdMethod(String idMethod) {
         this.idMethod = idMethod;
     }
 
     /**
      * Skip generating sql for this table (in the event it should not be created from scratch).
      * 
      * @return value of skipSql.
      */
     public boolean isSkipSql() {
         return (skipSql || isAlias() || isForReferenceOnly());
     }
 
     /**
      * Set whether this table should have its creation sql generated.
      * 
      * @param v
      *            Value to assign to skipSql.
      */
     public void setSkipSql(boolean v) {
         this.skipSql = v;
     }
 
     /**
      * JavaName of om object this entry references.
      * 
      * @return value of external.
      */
     public String getAlias() {
         return alias;
     }
 
     /**
      * Is this table specified in the schema or is there just a foreign key reference to it.
      * 
      * @return value of external.
      */
     public boolean isAlias() {
         return (alias != null);
     }
 
     /**
      * Set whether this table specified in the schema or is there just a foreign key reference to it.
      * 
      * @param v
      *            Value to assign to alias.
      */
     public void setAlias(String v) {
         this.alias = v;
     }
 
     /**
      * Interface which objects for this table will implement
      * 
      * @return value of interface.
      */
     public String getInterface() {
         return enterface;
     }
 
     /**
      * Interface which objects for this table will implement
      * 
      * @param v
      *            Value to assign to interface.
      */
     public void setInterface(String v) {
         this.enterface = v;
     }
 
     /**
      * When a table is abstract, it marks the business object class that is generated as being abstract. If you have a
      * table called "FOO", then the Foo BO will be <code>public abstract class Foo</code> This helps support class
      * hierarchies
      * 
      * @return value of abstractValue.
      */
     public boolean isAbstract() {
         return abstractValue;
     }
 
     /**
      * When a table is abstract, it marks the business object class that is generated as being abstract. If you have a
      * table called "FOO", then the Foo BO will be <code>public abstract class Foo</code> This helps support class
      * hierarchies
      * 
      * @param v
      *            Value to assign to abstractValue.
      */
     public void setAbstract(boolean v) {
         this.abstractValue = v;
     }
 
     /**
      * Get the value of package.
      * 
      * @return value of package.
      */
     public String getPackage() {
         if (pkg != null) {
             return pkg;
         } else {
             return this.getDatabase().getPackage();
         }
     }
 
     /**
      * Set the value of package.
      * 
      * @param v
      *            Value to assign to package.
      */
     public void setPackage(String v) {
         this.pkg = v;
     }
 
     /**
      * Returns a List containing all the columns in the table
      * 
      * @return a List containing all the columns
      */
     public List getColumns() {
         return columnList;
     }
 
     /**
      * Utility method to get the number of columns in this table
      */
     public int getNumColumns() {
         return columnList.size();
     }
 
     /**
      * Returns a List containing all the FKs in the table
      * 
      * @return a List containing all the FKs
      */
     public List getForeignKeys() {
         return foreignKeys;
     }
 
     /**
      * Returns a Collection of parameters relevant for the chosen id generation method.
      */
     public List getIdMethodParameters() {
         return idMethodParameters;
     }
 
     /**
      * A name to use for creating a sequence if one is not specified.
      * 
      * @return name of the sequence
      */
     public String getSequenceName() {
         String result = null;
         if (getIdMethod().equals(NATIVE)) {
             List idMethodParams = getIdMethodParameters();
             if (idMethodParams == null) {
                 result = getName() + "_SEQ";
             } else {
                 result = ((IdMethodParameter) idMethodParams.get(0)).getValue();
             }
         }
         return result;
     }
 
     /**
      * Returns a List containing all the indices in the table
      * 
      * @return A List containing all the indices
      */
     public List getIndices() {
         return indices;
     }
 
     /**
      * Returns a List containing all the UKs in the table
      * 
      * @return A List containing all the UKs
      */
     public List getUnices() {
         return unices;
     }
 
     /**
      * Returns a specified column.
      * 
      * @param name
      *            name of the column
      * @return Return a Column object or null if it does not exist.
      */
     public Column getColumn(String name) {
         return (Column) columnsByName.get(name);
     }
 
     /**
      * Returns a specified column.
      * 
      * @param javaName
      *            java name of the column
      * @return Return a Column object or null if it does not exist.
      */
     public Column getColumnByJavaName(String javaName) {
         return (Column) columnsByJavaName.get(javaName);
     }
 
     /**
      * Return the first foreign key that includes col in it's list of local columns. Eg. Foreign key (a,b,c) refrences
      * tbl(x,y,z) will be returned of col is either a,b or c.
      * 
      * @param col
      *            column name included in the key
      * @return Return a Column object or null if it does not exist.
      */
     public ForeignKey getForeignKey(String col) {
         ForeignKey firstFK = null;
         for (Iterator iter = foreignKeys.iterator(); iter.hasNext();) {
             ForeignKey key = (ForeignKey) iter.next();
             if (key.getLocalColumns().contains(col)) {
                 if (firstFK == null) {
                     firstFK = key;
                 } else {
                     // System.out.println(col+" is in multiple FKs.  This is not"
                     // + " being handled properly.");
                     // throw new IllegalStateException("Cannot call method if " +
                     // "column is referenced multiple times");
                 }
             }
         }
         return firstFK;
     }
 
     /**
      * Returns true if the table contains a specified column
      * 
      * @param col
      *            the column
      * @return true if the table contains the column
      */
     public boolean containsColumn(Column col) {
         return columnList.contains(col);
     }
 
     /**
      * Returns true if the table contains a specified column
      * 
      * @param name
      *            name of the column
      * @return true if the table contains the column
      */
     public boolean containsColumn(String name) {
         return (getColumn(name) != null);
     }
 
     /**
      * Set the parent of the table
      * 
      * @param parent
      *            the parant database
      */
     public void setDatabase(Database parent) {
         tableParent = parent;
     }
 
     /**
      * Get the parent of the table
      * 
      * @return the parant database
      */
     public Database getDatabase() {
         return tableParent;
     }
 
     /**
      * Flag to determine if code/sql gets created for this table. Table will be skipped, if return true.
      * 
      * @return value of forReferenceOnly.
      */
     public boolean isForReferenceOnly() {
         return forReferenceOnly;
     }
 
     /**
      * Flag to determine if code/sql gets created for this table. Table will be skipped, if set to true.
      * 
      * @param v
      *            Value to assign to forReferenceOnly.
      */
     public void setForReferenceOnly(boolean v) {
         this.forReferenceOnly = v;
     }
 
     /**
      * Returns a XML representation of this table.
      * 
      * @return XML representation of this table
      */
     @Override
     public String toString() {
         StringBuffer result = new StringBuffer();
 
         result.append("<table name=\"").append(name).append('\"');
 
         if (javaName != null) {
             result.append(" javaName=\"").append(javaName).append('\"');
         }
 
         if (idMethod != null) {
             result.append(" idMethod=\"").append(idMethod).append('\"');
         }
 
         if (skipSql) {
             result.append(" skipSql=\"").append(new Boolean(skipSql)).append('\"');
         }
 
         if (abstractValue) {
             result.append(" abstract=\"").append(new Boolean(abstractValue)).append('\"');
         }
 
         if (baseClass != null) {
             result.append(" baseClass=\"").append(baseClass).append('\"');
         }
 
         if (basePeer != null) {
             result.append(" basePeer=\"").append(basePeer).append('\"');
         }
 
         result.append(">\n");
 
         if (columnList != null) {
             for (Iterator iter = columnList.iterator(); iter.hasNext();) {
                 result.append(iter.next());
             }
         }
 
         if (foreignKeys != null) {
             for (Iterator iter = foreignKeys.iterator(); iter.hasNext();) {
                 result.append(iter.next());
             }
         }
 
         if (idMethodParameters != null) {
             Iterator iter = idMethodParameters.iterator();
             while (iter.hasNext()) {
                 result.append(iter.next());
             }
         }
 
         result.append("</table>\n");
 
         return result.toString();
     }
 
     /**
      * Returns the collection of Columns which make up the single primary key for this table.
      * 
      * @return A list of the primary key parts.
      */
     public List getPrimaryKey() {
         List pk = new ArrayList(columnList.size());
 
         Iterator iter = columnList.iterator();
         while (iter.hasNext()) {
             Column col = (Column) iter.next();
             if (col.isPrimaryKey()) {
                 pk.add(col);
             }
         }
         return pk;
     }
 
     /**
      * Determine whether this table has a primary key.
      * 
      * @return Whether this table has any primary key parts.
      */
     public boolean hasPrimaryKey() {
         return (getPrimaryKey().size() > 0);
     }
 
     /**
      * Returns all parts of the primary key, separated by commas.
      * 
      * @return A CSV list of primary key parts.
      */
     public String printPrimaryKey() {
         return printList(columnList);
     }
 
     /**
      * Returns the elements of the list, separated by commas.
      * 
      * @param list
      *            a list of Columns
      * @return A CSV list.
      */
     private String printList(List list) {
         StringBuffer result = new StringBuffer();
         boolean comma = false;
         for (Iterator iter = list.iterator(); iter.hasNext();) {
             Column col = (Column) iter.next();
             if (col.isPrimaryKey()) {
                 if (comma) {
                     result.append(',');
                 } else {
                     comma = true;
                 }
                 result.append(col.getName());
             }
         }
         return result.toString();
     }
 
     /**
      * Force all columns to set the correctGetters property.
      * 
      * @param value
      *            The new value of the correctGetters property.
      * @since 3.2
      */
     public void setCorrectGetters(Boolean value) {
         boolean correctGetters = value != null && value.booleanValue();
         for (Iterator it = columnList.iterator(); it.hasNext();) {
             Column col = (Column) it.next();
             col.setCorrectGetters(correctGetters);
         }
     }
 
     /**
      * Add an XML Specified option key/value pair to this element's option set.
      * 
      * @param key
      *            the key of the option.
      * @param value
      *            the value of the option.
      */
     public void addOption(String key, String value) {
         options.put(key, value);
     }
 
     /**
      * Get the value that was associated with this key in an XML option element.
      * 
      * @param key
      *            the key of the option.
      * @return The value for the key or a null.
      */
     public String getOption(String key) {
         return (String) options.get(key);
     }
 
     /**
      * Gets the full ordered hashtable array of items specified by XML option statements under this element.
      * <p>
      * 
      * Note, this is not thread save but since it's only used for generation which is single threaded, there should be
      * minimum danger using this in Velocity.
      * 
      * @return An Map of all options. Will not be null but may be empty.
      */
     public Map getOptions() {
         return options;
     }
 
     @Override
     public void empty() {
 
     }
 }