/*

  * $Source$

  * $Revision$

  *

  * Copyright (C) 2000 William Chesters

  *

  * Part of Melati (http://melati.org), a framework for the rapid

  * development of clean, maintainable web applications.

  *

  * Melati is free software; Permission is granted to copy, distribute

  * and/or modify this software under the terms either:

  *

  * a) the GNU General Public License as published by the Free Software

  *    Foundation; either version 2 of the License, or (at your option)

  *    any later version,

  *

  *    or

  *

  * b) any version of the Melati Software License, as published

  *    at http://melati.org

  *

  * You should have received a copy of the GNU General Public License and

  * the Melati Software License along with this program;

  * if not, write to the Free Software Foundation, Inc.,

  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the

  * GNU General Public License and visit http://melati.org to obtain the

  * Melati Software License.

  *

  * Feel free to contact the Developers of Melati (http://melati.org),

  * if you would like to work out a different arrangement than the options

  * outlined here.  It is our intention to allow Melati to be used by as

  * wide an audience as possible.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * Contact details for copyright holder:

  *

  *     William Chesters <williamc At paneris.org>

  *     http://paneris.org/~williamc

  *     Obrechtstraat 114, 2517VX Den Haag, The Netherlands

  */

 package org.melati.poem;

 import java.io.PrintStream;

 import java.sql.PreparedStatement;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.util.Enumeration;

 import org.melati.poem.dbms.Dbms;

 import org.melati.poem.util.EmptyEnumeration;

 import org.melati.poem.util.StringUtils;

 /**

  * Abstract {@link Table} column which is extended by the generated classes.

  *

  * @author WilliamC At paneris.org

  * @param <T> The type of the Column

  * 

  */

 public abstract class Column<T> implements FieldAttributes<T> {

   @SuppressWarnings("rawtypes")

   private Table table = null;

   private String name;

   private String quotedName;

   private SQLPoemType<T> type;

   private DefinitionSource definitionSource;

   private ColumnInfo info = null;

   /**

    * Constructor.

    * @param table this column belongs to

    * @param name of this Column

    * @param type datatype

    * @param definitionSource where it is being defined from

    */

   public Column(

     Table<?> table,

     String name,

     SQLPoemType<T> type,

     DefinitionSource definitionSource) {

     this.table = table;

     this.name = name;

     this.quotedName = table.getDatabase().quotedName(name);

     this.type = type;

     this.definitionSource = definitionSource;

   }

   // 

   // ================

   //  Initialisation

   // ================

   // 

   /**

    * @return the underlying Dbms

    */

   Dbms dbms() {

     return getDatabase().getDbms();

   }

   <O> void unifyType(SQLPoemType<O> storeType, DefinitionSource source) {

     PoemType<T> unified = dbms().canRepresent(storeType, type);

     if (unified == null || !(unified instanceof SQLPoemType))

       throw new TypeDefinitionMismatchException(this, storeType, source);

     type = (SQLPoemType<T>) unified;

   }

   void assertMatches(ResultSet colDesc)

       throws SQLException, TypeDefinitionMismatchException {

     PoemType<?> dbType = getDatabase().defaultPoemTypeOfColumnMetaData(colDesc);

     if (dbms().canRepresent(dbType, type) == null)

       throw new TypeDefinitionMismatchException(

         this,

         dbType,

         DefinitionSource.sqlMetaData);

   }

   @SuppressWarnings("unchecked")

   void setColumnInfo(ColumnInfo columnInfo) {

     try {

       unifyType(columnInfo.getType(), DefinitionSource.infoTables);

       columnInfo.setColumn(this);

       if (columnInfo.getDisplaylevel() == DisplayLevel.primary)

         table.setDisplayColumn(this);

       if (columnInfo.getSearchability() == Searchability.primary)

         table.setSearchColumn(this);

       info = columnInfo;

       table.notifyColumnInfo(info);

     } catch (Exception e) {

       throw new UnexpectedExceptionPoemException(

         e,

         "Setting column info for " + name + " to " + columnInfo);

     }

   }

   protected DisplayLevel defaultDisplayLevel() {

     return DisplayLevel.summary;

   }

   protected Searchability defaultSearchability() {

     return Searchability.yes;

   }

   protected Integer defaultDisplayOrderPriority() {

     return null;

   }

   protected boolean defaultSortDescending() {

     return false;

   }

   protected String defaultDisplayName() {

     return StringUtils.capitalised(getName());

   }

   protected int defaultDisplayOrder() {

     return 100;

   }

   protected String defaultDescription() {

     return null;

   }

   protected boolean defaultUserEditable() {

     return true;

   }

   protected boolean defaultUserCreateable() {

     return true;

   }

   protected boolean defaultIndexed() {

     return isTroidColumn();

   }

   protected boolean defaultUnique() {

     return isTroidColumn();

   }

   /**

    * @return the StandardIntegrityFix prevent

    */

   protected StandardIntegrityFix defaultIntegrityFix() {

     return StandardIntegrityFix.prevent;

   }

   protected int defaultWidth() {

     return 20;

   }

   protected int defaultHeight() {

     return 1;

   }

   protected int defaultPrecision() {

     return 22;

   }

   protected int defaultScale() {

     return 2;

   }

   protected String defaultRenderinfo() {

     return null;

   }

   @SuppressWarnings("unchecked")

   void createColumnInfo() throws PoemException {

     if (info == null) {

       info = (ColumnInfo)getDatabase().

           getColumnInfoTable().create(new Initialiser() {

         public void init(Persistent g) throws AccessPoemException {

           ColumnInfo i = (ColumnInfo)g;

           i.setName(getName());

           i.setDisplayname(defaultDisplayName());

           i.setDisplayorder(defaultDisplayOrder());

           i.setDescription(defaultDescription());

           i.setDisplaylevel(defaultDisplayLevel());

           i.setSearchability(defaultSearchability());

           i.setSortdescending(defaultSortDescending());

           i.setDisplayorderpriority(defaultDisplayOrderPriority());

           i.setTableinfoTroid(table.tableInfoID());

           i.setUsereditable(defaultUserEditable());

           i.setUsercreateable(defaultUserCreateable());

           i.setIndexed(defaultIndexed());

           i.setUnique(defaultUnique());

           i.setWidth(defaultWidth());

           i.setHeight(defaultHeight());

           i.setRenderinfo(defaultRenderinfo());

           i.setIntegrityfix(defaultIntegrityFix());

           i.setPrecision(defaultPrecision());

           i.setScale(defaultScale());

           getType().saveColumnInfo(i);

         }

       });

       // FIXME Repeating this in setColumnInfo(ColumnInfo) is a bad sign

       if (defaultDisplayLevel() == DisplayLevel.primary)

         table.setDisplayColumn(this);

       if (defaultSearchability() == Searchability.primary)

         table.setSearchColumn(this);

     }

   }

   void unifyWithIndex(String indexName, ResultSet index) throws SQLException, 

                               IndexUniquenessPoemException {

     boolean indexUnique = !index.getBoolean("NON_UNIQUE");

     if (indexUnique != getUnique()) 

         throw new IndexUniquenessPoemException(

           this,

           indexName,

           getUnique());

   }

   // 

   // ===========

   //  Accessors

   // ===========

   // 

   /**

    * @return the Database our table is in

    */

   public final Database getDatabase() {

     return getTable().getDatabase();

   }

   /**

    * @return our Table

    */

   @SuppressWarnings("unchecked")

   public final Table<Persistent> getTable() {

     return table;

   }

   final void setTable(Table<?> table) {

     this.table = table;

   }

   /**

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getName()

    */

   public final String getName() {

     return name;

   }

   /**

    * @return the name quoted appropriately for the DBMS

    */

   public final String quotedName() {

     return quotedName;

   }

   /**

    * @return the name in table.column notation

    */

   public final String fullQuotedName() {

     return table.quotedName() + "." + quotedName;

   }

   /**

    * Return a human readable name from the metadata.

    * 

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getDisplayName()

    */

   public final String getDisplayName() {

     return info.getDisplayname();

   }

   /**

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getDescription()

    */

   public final String getDescription() {

     return info.getDescription();

   }

   /**

    * The troid (<TT>id</TT>) of the column's entry in the <TT>columninfo</TT>

    * table.  It will always have one (except during initialisation, which the

    * application programmer will never see).

    * @return the troid of our record in the columnInfo table

    */

   final Integer columnInfoID() {

     return info == null ? null : info.troid();

   }

   /**

    * @return the metadata record for this Column

    */

   public final ColumnInfo getColumnInfo() {

     return info;

   }

   /**

    * @return the defined or default DsiplayLevel

    */

   public DisplayLevel getDisplayLevel() {

     return info == null ? defaultDisplayLevel() : info.getDisplaylevel();

   }

   /**

    * @param level the DisplayLevel to set

    */

   public void setDisplayLevel(DisplayLevel level) {

     if (info != null)

       info.setDisplaylevel(level);

   }

   /**

    * @return our defined or default Searchabillity

    */

   public Searchability getSearchability() {

     return info == null ? defaultSearchability() : info.getSearchability();

   }

   /**

    * @param searchability the Searchability to set

    */

   public void setSearchability(Searchability searchability) {

     if (info != null)

       info.setSearchability(searchability);

   }

   /**

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getUserEditable()

    */

   public final boolean getUserEditable() {

     return !isTroidColumn()

       && (info == null || info.getUsereditable().booleanValue());

   }

   /**

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getUserCreateable()

    */

   public final boolean getUserCreateable() {

     return !isTroidColumn()

       && (info == null || info.getUsercreateable().booleanValue());

   }

   /**

    * @return the SQLPoemType of this Column

    */

   public final SQLPoemType<T> getSQLType() {

     return type;

   }

   /**

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getType()

    */

   public final PoemType<T> getType() {

     return type;

   }

   /**

    * @return whether this is a Troid Column

    */

   public final boolean isTroidColumn() {

     return getType() instanceof TroidPoemType;

   }

   /**

    * A Deleted Column is a Column which signal whether 

    * the record has been soft-deleted.

    * @return whether this is a Deleted Column

    */

   public final boolean isDeletedColumn() {

     return getType() instanceof DeletedPoemType;

   }

   /**

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getIndexed()

    */

   public final boolean getIndexed() {

     return getUnique() || info.getIndexed().booleanValue();

   }

   /**

    * @return whether this Column's values are unique in this table

    */

   public final boolean getUnique() {

     return isTroidColumn() || info.getUnique().booleanValue();

   }

   /**

    * @return the specified or default IntegrityFix

    */

   public IntegrityFix getIntegrityFix() {

     IntegrityFix it = info.getIntegrityfix();

     return it == null ? defaultIntegrityFix() : it;

   }

   /**

    * @param fix the IntegrityFix to set

    */

   public void setIntegrityFix(StandardIntegrityFix fix) {

     info.setIntegrityfix(fix);

   }

   /**

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getRenderInfo()

    */

   public final String getRenderInfo() {

     return info.getRenderinfo();

   }

   /**

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getWidth()

    */

   public final int getWidth() {

     return info.getWidth().intValue();

   }

   /**

    * {@inheritDoc}

    * @see org.melati.poem.FieldAttributes#getHeight()

    */

   public final int getHeight() {

     return info.getHeight().intValue();

   }

   /**

    * @return the set or default DisplayOrderPriority

    */

   public final Integer getDisplayOrderPriority() {

     return info == null ? null : info.getDisplayorderpriority();

   }

   /**

    * Defaults to false.

    * @return whether this Column should be sorted in descending order 

    */

   public final boolean getSortDescending() {

     return info.getSortdescending() == null

       ? false

       : info.getSortdescending().booleanValue();

   }

   // 

   // ===========

   //  Utilities

   // ===========

   // 

   /**

    * {@inheritDoc}

    * @see java.lang.Object#toString()

    */

   public String toString() {

     return table.getName()

       + "."

       + name

       + ": "

       + getType().toString()

       + " (from "

       + definitionSource

       + ")";

   }

   /**

    * Print information about the structure of the Column to stdout.

    */

   public void dump() {

     dump(System.out);

   }

   /**

    * Print information to PrintStream. 

    * 

    * @param ps PrintStream to dump to

    */

   public void dump(PrintStream ps) {

     ps.println(toString());

   }

   /**

    * 

    * @param raw An object with an equivalent SQL type

    * @return the SQL euals clause that would capture equality with the raw

    */

   public String eqClause(Object raw) {

     return fullQuotedName()

       + (raw == null ? " IS NULL" : " = " + type.quotedRaw(raw));

   }

   private PreparedStatementFactory selectionWhereEq = null;

   private PreparedStatementFactory statementWhereEq() {

     if (selectionWhereEq == null)

       selectionWhereEq =

         new PreparedStatementFactory(

           getDatabase(),

           getTable().selectionSQL(

             getTable().quotedName(),

             fullQuotedName()

               + " = "

               + dbms().preparedStatementPlaceholder(getType()),

             null,

             false,

             true));

     return selectionWhereEq;

   }

   ResultSet resultSetWhereEq(Object raw) {

     SessionToken token = PoemThread.sessionToken();

     PreparedStatement ps =

       statementWhereEq().preparedStatement(token.transaction);

     type.setRaw(ps, 1, raw);

     return statementWhereEq().resultSet(token, ps);

   }

   /**

    * Not used in Melati or PanEris tree.

    * 

    * @param raw value 

    * @return an Enumeration of Integers 

    */

   /*

   Enumeration troidSelectionWhereEq(Object raw) {

     return new ResultSetEnumeration(resultSetWhereEq(raw)) {

       public Object mapped(ResultSet rs) throws SQLException {

         return new Integer(rs.getInt(1));

       }

     };

   }

   */

   /**

    * Get rows where column equal to value.

    * 

    * @param raw a raw value such as a String

    * @return an enumeration of Persistents

    */

   public Enumeration<Persistent> selectionWhereEq(Object raw) {

     return new ResultSetEnumeration<Persistent>(resultSetWhereEq(raw)) {

       public Object mapped(ResultSet rs) throws SQLException {

         return getTable().getObject(rs.getInt(1));

       }

     };

   }

   /**

    * Return the first one found or null if not found. 

    * 

    * @param raw Object of correct type for this Column

    * @return the first one found based upon default ordering

    */

   public Persistent firstWhereEq(Object raw) {

     Enumeration<Persistent> them = selectionWhereEq(raw);

     return them.hasMoreElements() ? (Persistent)them.nextElement() : null;

   }

   /**

    * Create a new CachedSelection of objects equal to this raw parameter. 

    * 

    * @param raw Object of correct type for this Column

    * @return a new CachedSelection of objects equal to raw.

    */

   @SuppressWarnings({ "rawtypes", "unchecked" })

   public CachedSelection cachedSelectionWhereEq(Object raw) {

     return new CachedSelection(getTable(), eqClause(raw), null);

   }

   // 

   // =======================================

   //  Reading/setting the column in records

   // =======================================

   // 

  /**

   * Retrieves the field value, with locking,

   * for this {@link Column}.

   * 

   * @param g  the {@link Persistent} to read

   * @return the Object itself

   * @throws AccessPoemException 

   *         if the current <code>AccessToken</code> 

   *         does not confer read access rights

   */

   public abstract Object getRaw(Persistent g) throws AccessPoemException;

  /**

   * Retrieves the field value, without locking,

   * for this <code>Column</code>.

   * 

   * @param g  the {@link Persistent} to read

   * @return the Object without checks

   */

   public abstract Object getRaw_unsafe(Persistent g);

  /**

   * Sets the field value, with locking,

   * for this <code>Column</code>.

   * 

   * @param g  the {@link Persistent} to modify

   * @param raw the value to set the field to 

   * @throws AccessPoemException 

   *         if the current <code>AccessToken</code> 

   *         does not confer write access rights

   * @throws ValidationPoemException 

   *         if the raw value is not valid

   */

   public abstract void setRaw(Persistent g, Object raw)

     throws AccessPoemException, ValidationPoemException;

  /**

   * Sets the field value, without locking,

   * for this <code>Column</code>.

   * 

   * @param g  the {@link Persistent} to modify

   * @param raw the value to set the field to 

   */

   public abstract void setRaw_unsafe(Persistent g, Object raw);

  /**

   * Retrieves the field value, with locking and  access control 

   * for this <code>Column</code>.

   * 

   * @param g  the {@link Persistent} to modify

   * @return either the value or what is represented by the value

   * @throws AccessPoemException 

   *         if the current <code>AccessToken</code> 

   *         does not confer read access rights

   * @throws PoemException 

   *         if any problem occurs

   */

   public abstract Object getCooked(Persistent g)

     throws AccessPoemException, PoemException;

  /**

   * Sets the field value, with locking, access control 

   * and validation for this <code>Column</code>.

   * 

   * @param g  the {@link Persistent} to modify

   * @param cooked  the value to set

   * @throws AccessPoemException 

   *         if the current <code>AccessToken</code> 

   *         does not confer read access rights

   * @throws ValidationPoemException 

   *         if the value is not valid

   */

   public abstract void setCooked(Persistent g, Object cooked)

     throws AccessPoemException, ValidationPoemException;

   /**

    * Thrown when any unforeseen problem arises loading a {@link Column}.

    */

   public static class LoadException extends UnexpectedExceptionPoemException {

     private Column<?> column;

     /**

      * Constructor.

      * @param column Column relevant to

      * @param problem the Exception

      */

     public LoadException(Column<?> column, Exception problem) {

       super(problem);

       this.column = column;

     }

     /** @return Returns the message */

     public String getMessage() {

       return "An unexpected problem arose loading "

         + column

         + " from the "

         + "database:\n"

         + subException;

     }

     /**

      * @return Returns the column.

      */

      @SuppressWarnings("rawtypes")

     protected Column getColumn() {

       return column;

     }

   }

   /**

    * Load a Persistent field from a column of a ResultSet.

    * 

    * TODO Double validation

    * @param rs A <code>ResultSet</code>containing the value(s) to load

    * @param rsCol The index in the <tt>ResultSet</tt> of this {link column}

    * @param g The {@link Persistent} to load db values into

    * @throws LoadException

    */

   void load_unsafe(ResultSet rs, int rsCol, Persistent g)

     throws LoadException {

     try {

       setRaw_unsafe(g, type.getRaw(rs, rsCol));

     } catch (Exception e) {

       throw new LoadException(this, e);

     }

   }

   /**

    * Set value in a PreparedStatement which is to be used to save to database.

    *

    * TODO Double validation

    * @param g The {@link Persistent} containing unsaved values

    * @param ps <tt>PreparedStatement</tt> to save this column

    * @param psCol index of this Column in the PreparedStatement

    */

   void save_unsafe(Persistent g, PreparedStatement ps, int psCol) {

     try {

       type.setRaw(ps, psCol, getRaw_unsafe(g));

     } catch (Exception e) {

       throw new FieldContentsPoemException(this, e); 

     }

   }

   // 

   // ============

   //  Operations

   // ============

   // 

   /**

    * Return a Field of the same type as this Column from the Persistent.

    * @param g the Persistent

    * @return a Field

    */

   public abstract Field<T> asField(Persistent g);

   /**

    * Return a Field of the same type as this Column with default attributes.

    * @return the empty Field

    */

   public Field<T> asEmptyField() {

     return new Field<T>((T) null, this);

   }

   /**

    * Thrown when any unforseen problem arises setting the value 

    * of a {@link Column}.

    */

   public static class SettingException extends NormalPoemException {

     /** The Persistent to which this Column belongs. */

     public Persistent persistent;

     /** The Column setting which caused the problem. */

     public Column<?> column;

     /** The description of the Column. */

     public String columnDesc;

     /**

      * Constructor.

      * @param persistent the Persistent with the problem

      * @param column he Column with the problem

      * @param trouble the problem

      */

     public SettingException(Persistent persistent, Column<?> column, Exception trouble) {

       super(trouble);

       this.persistent = persistent;

       this.column = column;

       columnDesc =

         "field `"

           + column.getDisplayName()

           + "' in object `"

           + persistent.displayString()

           + "' of type `"

           + column.getTable().getDisplayName()

           + "'";

     }

     /** @return the message */

     public String getMessage() {

       return "Unable to set " + columnDesc + "\n" + subException;

     }

   }

   /**

    * Set the value from its String representation, if possible.

    * 

    * Throws SettingException if the String value cannot be 

    * converted to the appropriate type 

    * @param g the Persistent to alter

    * @param rawString the String representation of the value to set

    */

   public void setRawString(Persistent g, String rawString) {

     Object raw;

     try {

       raw = getType().rawOfString(rawString);

     } catch (Exception e) {

       throw new SettingException(g, this, e);

     }

     setRaw(g, raw);

   }

   /**

    * Return an Enumeration of {@link Persistent}s from the 

    * Table this column refers to, if this is a reference column, 

    * otherwise the Empty Enumeration.

    * @param object A persistent of the type referred to by this column

    * @return an Enumeration {@link Persistent}s referencing this Column of the Persistent

    */

   public Enumeration<Persistent> referencesTo(Persistent object) {

     if (getType() instanceof PersistentReferencePoemType)

       if(((PersistentReferencePoemType) getType()).targetTable() == object.getTable()) { 

         if (getType() instanceof ReferencePoemType)

           return selectionWhereEq(object.troid());

         else if (getType() instanceof StringKeyReferencePoemType)

           return selectionWhereEq(

               object.getField(

                   ((StringKeyReferencePoemType)getType()).targetKeyName()).getRawString());

         else throw new PoemBugPoemException("Unanticipated type " + getType());

       }

     return new EmptyEnumeration<Persistent>();

   }

   /**

    * Ensures a row exists for which this column matches when compared with

    * the given {@link Persistent}.

    * 

    * The given object is used to create a new row if

    * necessary, in which case it will be assigned the next troid and

    * cached.

    * @param orCreate the Persistent to use as criteria and ensure

    * @return the existing or newly created Persistent

    */

   public Persistent ensure(Persistent orCreate) {

     Persistent there = firstWhereEq(getRaw_unsafe(orCreate));

     if (there == null) {

       getTable().create(orCreate);

       return orCreate;

     } else

       return there;

   }

   /**

    * Find the next free value in an Integer column.

    * 

    * This is not used in Melati, but is used in Bibliomania. 

    * Throws AppBugPoemException if this Column is not an Integer column.

    * 

    * @param whereClause the SQL fragment to use

    * @return the incremented value 

    * @since 04/05/2000

    */

   public int firstFree(String whereClause) {

     if (! (getType() instanceof IntegerPoemType)) 

       throw new AppBugPoemException("firstFree called on a non Integer column");

     getTable().readLock();

     String querySelection = 

         quotedName

       + " + 1 "

       + "FROM "

       + getTable().quotedName()

       + " AS t1 "

       + "WHERE "

       + (whereClause == null ? "" : "(t1." + whereClause + ") AND ")

       + "NOT EXISTS ("

       + "SELECT * FROM "

       + getTable().quotedName()

       + " AS t2 "

       + "WHERE "

       + (whereClause == null ? "" : "(t2." + whereClause + ") AND ")

       + "t2."

       + quotedName

       + " = t1."

       + quotedName

       + " + 1) ";

     String query = getDatabase().getDbms().selectLimit(querySelection, 1); 

     ResultSet results = getDatabase().sqlQuery(query);

     try {

       if (results.next())

         return results.getInt(1);

       else

         return 0;

     } catch (SQLException e) {

       throw new SQLSeriousPoemException(e);

     }

   }

   /**

    * @param colDescs from DatabaseMetaData.getColumns, with cursor at current row

    * @throws SQLException 

    */

   public void unifyWithMetadata(ResultSet colDescs) throws SQLException {

     if (info == null)

       return;

     String remarks = colDescs.getString("REMARKS");

     if (getDescription() == null) {

       if (remarks != null && !remarks.trim().equals("")) {

         info.setDescription(remarks);

         getDatabase().log("Adding comment to column " + table + "." + name + 

             " from SQL metadata:" + remarks);

       }

     } else {

       if (!this.getDescription().equals(remarks)) {

         String sql = this.dbms().alterColumnAddCommentSQL(this, null); 

         if (sql != null)

           this.getDatabase().modifyStructure(sql);          

       }

     }

   }

 }