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;
 	}
 }