Coverage Report

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

Classes in this File
Line Coverage
Branch Coverage
Complexity
Table
0/284
0/126
1.918
 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
          */
         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;
         }
 }