Java 类org.hibernate.mapping.Column 实例源码

@Override
public String getModifyColumnSql(Mapping mapping, Column column, boolean changeNotNull, boolean changeType)
{
    String columnName = column.getQuotedName(this);

    String nullStr = "";
    if( changeNotNull )
    {
        nullStr = column.isNullable() ? " NULL" : " NOT NULL";
    }
    String typeStr = "";
    if( changeType )
    {
        typeStr = ' ' + column.getSqlType(this, mapping);
    }

    return "MODIFY (" + columnName + typeStr + nullStr + ")";
}

@Override
public String getModifyColumnSql(Mapping mapping, Column column, boolean changeNotNull, boolean changeType)
{
    StringBuilder sbuf = new StringBuilder();
    String columnName = column.getQuotedName(this);

    if( changeNotNull )
    {
        sbuf.append("ALTER COLUMN ");
        sbuf.append(columnName).append(' ');
        sbuf.append(column.isNullable() ? "DROP" : "SET");
        sbuf.append(" NOT NULL");
    }
    if( changeType )
    {
        if( changeNotNull )
        {
            sbuf.append(", ");
        }
        sbuf.append("ALTER COLUMN ");
        sbuf.append(columnName).append(" TYPE ").append(column.getSqlType(this, mapping));
    }
    return sbuf.toString();
}

@SuppressWarnings({"unchecked"})
private void addIndexSQL(List<String> sqlStrings, Table table, Set<Column> colSet)
{
    Iterator<Index> indexIterator = table.getIndexIterator();
    while( indexIterator.hasNext() )
    {
        Index index = indexIterator.next();
        Iterator<Column> colIter = index.getColumnIterator();
        boolean found = false;
        while( colIter.hasNext() )
        {
            Column col = colIter.next();
            if( colSet.contains(col) )
            {
                found = true;
                break;
            }
        }
        if( found && (!extDialect.supportsAutoIndexForUniqueColumn() || !hasUniqueIndex(index, table)) )
        {
            sqlStrings.add(index.sqlCreateString(dialect, mapping, defaultCatalog, defaultSchema));
        }
    }
}

@SuppressWarnings("unchecked")
private boolean hasUniqueIndex(Index index, Table table)
{
    HashSet<Column> indexCols = new HashSet<Column>();
    Iterator<Column> icolIter = index.getColumnIterator();
    while( icolIter.hasNext() )
    {
        Column col = icolIter.next();
        indexCols.add(col);
        if( index.getColumnSpan() == 1 && table.getColumn(col).isUnique() )
        {
            return true;
        }
    }
    Iterator<UniqueKey> iter = table.getUniqueKeyIterator();
    while( iter.hasNext() )
    {
        UniqueKey uk = iter.next();
        if( uk.getColumnSpan() == indexCols.size() && indexCols.containsAll(uk.getColumns()) )
        {
            return true;
        }
    }
    return false;
}

/**
 * @param tableName
 * @param columnName
 * @param changeNotNull
 * @param nullable Pass in null to use the annotation on the column. This is
 *            not always possible (see Redmine #3329).
 * @param changeType
 * @return
 */
public List<String> getModifyColumnSQL(String tableName, String columnName, boolean changeNotNull,
    boolean changeType)
{
    List<String> sqlStrings = new ArrayList<String>();

    Table table = findTable(tableName);
    Column column = table.getColumn(new Column(columnName));

    StringBuffer alter = new StringBuffer("alter table ")
        .append(table.getQualifiedName(dialect, defaultCatalog, defaultSchema)).append(' ')
        .append(extDialect.getModifyColumnSql(mapping, column, changeNotNull, changeType));

    sqlStrings.add(alter.toString());
    return sqlStrings;
}

public List<String> getDropColumnSQL(String tableName, String... columns)
{
    List<String> sqlStrings = new ArrayList<String>();

    Table table = findTable(tableName);
    for( String columnName : columns )
    {
        Column column = table.getColumn(new Column(columnName));
        if( column == null )
        {
            throw new RuntimeException("Could not find column " + columnName + " on table " + tableName);
        }
        sqlStrings.add(extDialect.getDropColumnSql(table.getQualifiedName(dialect, defaultCatalog, defaultSchema),
            column));
    }
    return sqlStrings;
}

public List<String> getAddNotNullSQL(String tableName, String... columns)
{
    List<String> sqlStrings = new ArrayList<String>();

    Table table = findTable(tableName);
    for( String columnName : columns )
    {
        Column column = table.getColumn(new Column(columnName));

        StringBuffer alter = new StringBuffer("alter table ")
            .append(table.getQualifiedName(dialect, defaultCatalog, defaultSchema)).append(' ')
            .append(extDialect.getAddNotNullSql(mapping, column));
        sqlStrings.add(alter.toString());
    }
    return sqlStrings;
}

public Collection<? extends String> getAddIndexesRawIfRequired(Session session, String tableName,
    String[]... indexes)
{
    List<String> sqlStrings = new ArrayList<String>();
    final Table table = findTable(tableName);
    Map<Set<String>, String> revIndexMap = getExistingIndexes(table, session);
    for( String[] index : indexes )
    {
        Index indexObj = new Index();
        indexObj.setTable(table);
        indexObj.setName(index[0]);
        for( int i = 1; i < index.length; i++ )
        {
            Column col = new Column(index[i]);
            indexObj.addColumn(col);
        }
        processIndex(table, indexObj, revIndexMap, sqlStrings);
    }
    return sqlStrings;
}

public Collection<? extends String> getAddIndexesRaw(String tableName, String[]... indexes)
{
    List<String> sqlStrings = new ArrayList<String>();
    final Table table = findTable(tableName);
    for( String[] index : indexes )
    {
        Index indexObj = new Index();
        indexObj.setTable(table);
        indexObj.setName(index[0]);
        for( int i = 1; i < index.length; i++ )
        {
            Column col = new Column(index[i]);
            indexObj.addColumn(col);
        }
        sqlStrings.add(indexObj.sqlCreateString(dialect, mapping, defaultCatalog, defaultSchema));
    }
    return sqlStrings;
}

@SuppressWarnings("unchecked")
private void processIndex(Table table, Index index, Map<Set<String>, String> revIndexMap, List<String> sqlStrings)
{
    Iterator<Column> colIter = index.getColumnIterator();
    Set<String> indexCols = new HashSet<String>();
    while( colIter.hasNext() )
    {
        Column col = colIter.next();
        indexCols.add(col.getName().toLowerCase());
    }
    String existingIndex = revIndexMap.get(indexCols);
    if( existingIndex != null )
    {
        if( existingIndex.equalsIgnoreCase(index.getName()) )
        {
            return;
        }
        else
        {
            sqlStrings.add(extDialect.getDropIndexSql(table.getName(), '`' + existingIndex + '`'));
        }
    }
    sqlStrings.add(index.sqlCreateString(dialect, mapping, defaultCatalog, defaultSchema));
}

private void addConstraintToColumn(final String columnName ) {
    Column column = table.getColumn(
            new Column(
                    mappings.getPhysicalColumnName( columnName, table )
            )
    );
    if ( column == null ) {
        throw new AnnotationException(
                "@Index references a unknown column: " + columnName
        );
    }
    if ( unique )
        table.getOrCreateUniqueKey( indexName ).addColumn( column );
    else
        table.getOrCreateIndex( indexName ).addColumn( column );
}

private void bindLogicalToPhysical(String logicalName, Column physicalColumn) throws DuplicateMappingException {
    final String logicalKey = logicalName.toLowerCase();
    final String physicalName = physicalColumn.getQuotedName();
    final String existingPhysicalName = ( String ) logicalToPhysical.put( logicalKey, physicalName );
    if ( existingPhysicalName != null ) {
        boolean areSamePhysicalColumn = physicalColumn.isQuoted()
                ? existingPhysicalName.equals( physicalName )
                : existingPhysicalName.equalsIgnoreCase( physicalName );
        if ( ! areSamePhysicalColumn ) {
            throw new DuplicateMappingException(
                    " Table [" + tableName + "] contains logical column name [" + logicalName
                            + "] referenced by multiple physical column names: [" + existingPhysicalName
                            + "], [" + physicalName + "]",
                    "column-binding",
                    tableName + "." + logicalName
            );
        }
    }
}

private static void matchColumnsByProperty(Property property, Map<Column, Set<Property>> columnsToProperty) {
        if ( property == null ) return;
        if ( "noop".equals( property.getPropertyAccessorName() )
                || "embedded".equals( property.getPropertyAccessorName() ) ) {
            return;
        }
// FIXME cannot use subproperties becasue the caller needs top level properties
//      if ( property.isComposite() ) {
//          Iterator subProperties = ( (Component) property.getValue() ).getPropertyIterator();
//          while ( subProperties.hasNext() ) {
//              matchColumnsByProperty( (Property) subProperties.next(), columnsToProperty );
//          }
//      }
        else {
            Iterator columnIt = property.getColumnIterator();
            while ( columnIt.hasNext() ) {
                Object column = columnIt.next(); //can be a Formula so we don't cast
                //noinspection SuspiciousMethodCalls
                if ( columnsToProperty.containsKey( column ) ) {
                    columnsToProperty.get( column ).add( property );
                }
            }
        }
    }

public void linkValueUsingDefaultColumnNaming(
        Column referencedColumn,
        PersistentClass referencedEntity,
        SimpleValue value) {
    String columnName;
    String logicalReferencedColumn = getMappings().getLogicalColumnName(
            referencedColumn.getQuotedName(), referencedEntity.getTable()
    );
    columnName = buildDefaultColumnName( referencedEntity, logicalReferencedColumn );
    //yuk side effect on an implicit column
    setLogicalColumnName( columnName );
    setReferencedColumn( logicalReferencedColumn );
    initMappingColumn(
            columnName,
            null, referencedColumn.getLength(),
            referencedColumn.getPrecision(),
            referencedColumn.getScale(),
            getMappingColumn() != null ? getMappingColumn().isNullable() : false,
            referencedColumn.getSqlType(),
            getMappingColumn() != null ? getMappingColumn().isUnique() : false,
            false
    );
    linkWithValue( value );
}

/**
 * Called to apply column definitions from the referenced FK column to this column.
 *
 * @param column the referenced column.
 */
public void overrideFromReferencedColumnIfNecessary(org.hibernate.mapping.Column column) {
    if (getMappingColumn() != null) {
        // columnDefinition can also be specified using @JoinColumn, hence we have to check
        // whether it is set or not
        if ( StringHelper.isEmpty( sqlType ) ) {
            sqlType = column.getSqlType();
            getMappingColumn().setSqlType( sqlType );
        }

        // these properties can only be applied on the referenced column - we can just take them over
        getMappingColumn().setLength(column.getLength());
        getMappingColumn().setPrecision(column.getPrecision());
        getMappingColumn().setScale(column.getScale());
    }
}

public static void linkJoinColumnWithValueOverridingNameIfImplicit(
        PersistentClass referencedEntity,
        Iterator columnIterator,
        Ejb3JoinColumn[] columns,
        SimpleValue value) {
    for (Ejb3JoinColumn joinCol : columns) {
        Column synthCol = (Column) columnIterator.next();
        if ( joinCol.isNameDeferred() ) {
            //this has to be the default value
            joinCol.linkValueUsingDefaultColumnNaming( synthCol, referencedEntity, value );
        }
        else {
            joinCol.linkWithValue( value );
            joinCol.overrideFromReferencedColumnIfNecessary( synthCol );
        }
    }
}

public boolean matches(ForeignKey fk) {
    if ( refTable.equalsIgnoreCase( fk.getReferencedTable().getName() ) ) {
        if ( fk.getColumnSpan() == references.size() ) {
            List fkRefs;
            if ( fk.isReferenceToPrimaryKey() ) {
                fkRefs = fk.getReferencedTable().getPrimaryKey().getColumns();
            }
            else {
                fkRefs = fk.getReferencedColumns();
            }
            for ( int i = 0; i < fk.getColumnSpan(); i++ ) {
                Column column = fk.getColumn( i );
                Column ref = ( Column ) fkRefs.get( i );
                if ( !hasReference( column, ref ) ) {
                    return false;
                }
            }
            return true;
        }
    }
    return false;
}

protected Table generateIdTableDefinition(PersistentClass entityMapping) {
    Table idTable = new Table( entityMapping.getTemporaryIdTableName() );
    if ( catalog != null ) {
        idTable.setCatalog( catalog );
    }
    if ( schema != null ) {
        idTable.setSchema( schema );
    }
    Iterator itr = entityMapping.getTable().getPrimaryKey().getColumnIterator();
    while( itr.hasNext() ) {
        Column column = (Column) itr.next();
        idTable.addColumn( column.clone()  );
    }
    Column sessionIdColumn = new Column( "hib_sess_id" );
    sessionIdColumn.setSqlType( "CHAR(36)" );
    sessionIdColumn.setComment( "Used to hold the Hibernate Session identifier" );
    idTable.addColumn( sessionIdColumn );

    idTable.setComment( "Used to hold id values for the " + entityMapping.getEntityName() + " class" );
    return idTable;
}

private String fieldType(Column currentColumn) {
    TypeTranslator translator = serviceRegistry.getService( TypeTranslator.class );
    Type valueType = currentColumn.getValue().getType();
    GridType gridType = translator.getType( valueType );
    if ( gridType instanceof EnumType ) {
        return enumFieldType( (EnumType) gridType );
    }
    if ( gridType instanceof YesNoType ) {
        return STRING_CLASS_NAME;
    }
    if ( gridType instanceof NumericBooleanType ) {
        return INTEGER_CLASS_NAME;
    }
    Class<?> returnedClass = valueType.getReturnedClass();
    if ( Character.class.equals( returnedClass ) ) {
        return STRING_CLASS_NAME;
    }
    return returnedClass.getName();
}

public static void bindColumn(Element node, Column column, boolean isNullable) {
    Attribute lengthNode = node.attribute( "length" );
    if ( lengthNode != null ) column.setLength( Integer.parseInt( lengthNode.getValue() ) );
    Attribute scalNode = node.attribute( "scale" );
    if ( scalNode != null ) column.setScale( Integer.parseInt( scalNode.getValue() ) );
    Attribute precNode = node.attribute( "precision" );
    if ( precNode != null ) column.setPrecision( Integer.parseInt( precNode.getValue() ) );

    Attribute nullNode = node.attribute( "not-null" );
    column.setNullable( nullNode == null ? isNullable : nullNode.getValue().equals( "false" ) );

    Attribute unqNode = node.attribute( "unique" );
    if ( unqNode != null ) column.setUnique( unqNode.getValue().equals( "true" ) );

    column.setCheckConstraint( node.attributeValue( "check" ) );
    column.setDefaultValue( node.attributeValue( "default" ) );

    Attribute typeNode = node.attribute( "sql-type" );
    if ( typeNode != null ) column.setSqlType( typeNode.getValue() );

    Element comment = node.element("comment");
    if (comment!=null) column.setComment( comment.getTextTrim() );

}

public void testForeignKeyCreation() {
    PersistentClass classMapping = getCfg().getClassMapping("org.hibernate.test.propertyref.basic.Account");

    Iterator foreignKeyIterator = classMapping.getTable().getForeignKeyIterator();
    boolean found = false;
    while ( foreignKeyIterator.hasNext() ) {
        ForeignKey element = (ForeignKey) foreignKeyIterator.next();
        if(element.getReferencedEntityName().equals(Person.class.getName() ) ) {

            if(!element.isReferenceToPrimaryKey() ) {
                List referencedColumns = element.getReferencedColumns();
                Column column = (Column) referencedColumns.get(0);
                if(column.getName().equals("person_userid") ) {
                    found = true; // extend test to include the columns
                }               
            }
        }
    }

    assertTrue("Property ref foreign key not found",found);
}

@SuppressWarnings("unchecked")
protected String[] getColumnNames( Class peristentClass, String[] includedFields )
        throws MappingException
{
    Collection columns = new ArrayList();
    for ( int i = 0; i < includedFields.length; i++ )
    {
        String propertyName = includedFields[i];
        Property property = getMapping( peristentClass ).getProperty( propertyName );

        for ( Iterator it = property.getColumnIterator(); it.hasNext(); )
        {
            Column col = ( Column ) it.next();
            columns.add( col.getName() );
        }
    }
    return ( String[] ) columns.toArray( new String[columns.size()] );
}

protected void setPKColumnGenerator(Mappings mappings, RootClass clazz, Table tab, com.manydesigns.portofino.model.database.Column column, SimpleValue id, Generator generator) {
    if (column.isAutoincrement()) {
        manageIdentityGenerator(mappings, tab, id);
    } else if (generator != null) {
        if (generator instanceof SequenceGenerator) {
            manageSequenceGenerator(mappings, tab, id, (SequenceGenerator) generator);
        } else if (generator instanceof
                            com.manydesigns.portofino.model.database.TableGenerator) {
            manageTableGenerator(mappings, tab, id,
                    (com.manydesigns.portofino.model.database.TableGenerator) generator);
        } else if (generator instanceof
                            com.manydesigns.portofino.model.database.IncrementGenerator){
            manageIncrementGenerator(mappings, tab, id, clazz.getEntityName());
        }
    }
}

@Test
public void testEntityToDatabaseBindingMetadata() {
    Metadata metadata = MetadataExtractorIntegrator.INSTANCE.getMetadata();

    for ( PersistentClass persistentClass : metadata.getEntityBindings()) {
        Table table = persistentClass.getTable();
        LOGGER.info( "Entity: {} is mapped to table: {}",
                     persistentClass.getClassName(),
                     table.getName()
        );

        for(Iterator propertyIterator =
                persistentClass.getPropertyIterator(); propertyIterator.hasNext(); ) {
            Property property = (Property) propertyIterator.next();
            for(Iterator columnIterator =
                    property.getColumnIterator(); columnIterator.hasNext(); ) {
                Column column = (Column) columnIterator.next();
                LOGGER.info( "Property: {} is mapped on table column: {} of type: {}",
                             property.getName(),
                             column.getName(),
                             column.getSqlType()
                );
            }
        }
    }
}

@SuppressWarnings("rawtypes")
private void normalizeColumns(Table table, String entityName) {

    Iterator iterator = table.getColumnIterator();
    while (iterator.hasNext()) {

        Column column = (Column) iterator.next();

        String name = strategy.columnName(column.getName());
        String sqlType = strategy.sqlType(table.getName(), column.getSqlType());
        int sqlPrecision = strategy.sqlPrecision(table.getName(), column.getSqlType(), column.getPrecision());
        int sqlScale = strategy.sqlScale(table.getName(), column.getSqlType(), column.getScale());

        column.setName(name);
        column.setSqlType(sqlType);
        column.setPrecision(sqlPrecision);
        column.setScale(sqlScale);

    }

}

@SuppressWarnings("unchecked")
protected String[] getColumnNames( Class peristentClass, String[] includedFields )
        throws MappingException
{
    Collection columns = new ArrayList();
    for ( int i = 0; i < includedFields.length; i++ )
    {
        String propertyName = includedFields[i];
        Property property = getMapping( peristentClass ).getProperty( propertyName );

        for ( Iterator it = property.getColumnIterator(); it.hasNext(); )
        {
            Column col = ( Column ) it.next();
            columns.add( col.getName() );
        }
    }
    return ( String[] ) columns.toArray( new String[columns.size()] );
}

protected void setPKColumnGenerator(Mappings mappings, RootClass clazz, Table tab, com.manydesigns.portofino.model.database.Column column, SimpleValue id, Generator generator) {
    if (column.isAutoincrement()) {
        manageIdentityGenerator(mappings, tab, id);
    } else if (generator != null) {
        if (generator instanceof SequenceGenerator) {
            manageSequenceGenerator(mappings, tab, id, (SequenceGenerator) generator);
        } else if (generator instanceof
                            com.manydesigns.portofino.model.database.TableGenerator) {
            manageTableGenerator(mappings, tab, id,
                    (com.manydesigns.portofino.model.database.TableGenerator) generator);
        } else if (generator instanceof
                            com.manydesigns.portofino.model.database.IncrementGenerator){
            manageIncrementGenerator(mappings, tab, id, clazz.getEntityName());
        }
    }
}

public boolean matches(ForeignKey fk) {
    if (refTable.equalsIgnoreCase(fk.getReferencedTable().getName())) {
        if (fk.getColumnSpan() == references.size()) {
            List fkRefs;
            if (fk.isReferenceToPrimaryKey()) {
                fkRefs = fk.getReferencedTable().getPrimaryKey().getColumns();
            } else {
                fkRefs = fk.getReferencedColumns();
            }

            for (int i = 0; i < fk.getColumnSpan(); i++) {
                Column column = fk.getColumn(i);
                Column ref = (Column)fkRefs.get(i);
                if (!hasReference(column, ref)) {
                    return false;
                }
            }

            return false;
        }
    }

    return false;
}

@Override
public void start(Configuration configuration, SessionFactoryImplementor sessionFactoryImplementor) {
    Iterator<Table> tables = configuration.getTableMappings();
    while (tables.hasNext()) {
        Table table = tables.next();
        if (table.isPhysicalTable()) {
            String tableName = table.getQuotedName();
            // do something with table
            Iterator<Column> columns = (Iterator<Column>) table.getColumnIterator();
            while (columns.hasNext()) {
                Column column = columns.next();
                String columnName = column.getCanonicalName();
                // do something with column
            }
            //TODO handle unique constraints?
        }
    }
    throw new RuntimeException("STARTED!");
}

@Override
public String getModifyColumnSql(Mapping mapping, Column column, boolean changeNotNull, boolean changeType)
{
    String columnName = column.getQuotedName(this);
    String nullStr = column.isNullable() ? " NULL" : " NOT NULL";
    String typeStr = ' ' + column.getSqlType(this, mapping);
    return "ALTER COLUMN " + columnName + typeStr + nullStr;
}

@Override
public String getAddNotNullSql(Mapping mapping, Column column)
{
    String columnName = column.getQuotedName(this);

    String typeStr = ' ' + column.getSqlType(this, mapping);
    return "ALTER COLUMN " + columnName + typeStr + " NOT NULL";
}

@Override
public String getDropColumnSql(String table, Column column)
{
    String dropSQL = dropConstraintsSQL.replaceAll("\\$table", Matcher.quoteReplacement(table));
    dropSQL = dropSQL.replaceAll("\\$column", Matcher.quoteReplacement(column.getName()));
    return dropSQL + "\nalter table " + table + " drop column " + column.getQuotedName(this);
}

public List<String> getAddColumnsSQL(String tableName, String... columnNames)
{
    List<String> sqlStrings = new ArrayList<String>();

    Table table = findTable(tableName);
    for( String columnName : columnNames )
    {
        Column column = table.getColumn(new Column(columnName));

        StringBuffer alter = new StringBuffer("alter table ")
            .append(table.getQualifiedName(dialect, defaultCatalog, defaultSchema)).append(' ')
            .append(dialect.getAddColumnString());
        alter.append(' ').append(column.getQuotedName(dialect)).append(' ')
            .append(column.getSqlType(dialect, mapping));

        boolean useUniqueConstraint = extDialect.supportsModifyWithConstraints() && column.isUnique()
            && dialect.supportsUnique() && (!column.isNullable() || dialect.supportsNotNullUnique());
        if( useUniqueConstraint )
        {
            alter.append(" unique");
        }
        if( column.hasCheckConstraint() && dialect.supportsColumnCheck() )
        {
            alter.append(" check(").append(column.getCheckConstraint()).append(")");
        }

        String columnComment = column.getComment();
        if( columnComment != null )
        {
            alter.append(dialect.getColumnComment(columnComment));
        }
        sqlStrings.add(alter.toString());
    }
    return sqlStrings;
}

public List<String> getAddIndexesForColumns(String tableName, String... columnNames)
{
    Set<Column> colSet = new HashSet<Column>();
    for( String columnName : columnNames )
    {
        colSet.add(new Column(columnName));
    }
    List<String> sqlStrings = new ArrayList<String>();

    Table table = findTable(tableName);
    addIndexSQL(sqlStrings, table, colSet);
    return sqlStrings;
}

public String getAddNamedIndex(String tableName, String indexName, String... columnNames)
{
    Index index = new Index();
    index.setName(indexName);
    index.setTable(findTable(tableName));
    for( String columnName : columnNames )
    {
        index.addColumn(new Column(columnName));
    }
    return index.sqlCreateString(dialect, mapping, defaultCatalog, defaultSchema);
}

public List<String> getRenameColumnSQL(String tableName, String columnName, String newColumnName)
{
    List<String> sqlStrings = new ArrayList<String>();

    Table table = findTable(tableName);

    Column column = table.getColumn(new Column(columnName));
    String alter = null;
    alter = extDialect.getRenameColumnSql(table.getQualifiedName(dialect, defaultCatalog, defaultSchema), column,
        newColumnName);
    sqlStrings.add(alter);

    return sqlStrings;
}

public List<String> getAddNotNullSQLIfRequired(Session session, String tableName, String... columns)
{
    final Table table = findTable(tableName);

    final List<String> sqlStrings = new ArrayList<String>();
    final Set<String> colset = new HashSet<String>(Arrays.asList(columns));
    session.doWork(new Work()
    {
        @Override
        public void execute(Connection connection) throws SQLException
        {
            ResultSet colresult = connection.getMetaData().getColumns(getDefaultCatalog(),
                extDialect.getNameForMetadataQuery(getDefaultSchema(), false),
                extDialect.getNameForMetadataQuery(table.getName(), table.isQuoted()), "%");
            try
            {
                while( colresult.next() )
                {
                    String columnName = colresult.getString("COLUMN_NAME").toLowerCase();
                    if( colset.contains(columnName)
                        && "yes".equals(colresult.getString("IS_NULLABLE").toLowerCase()) )
                    {
                        Column column = table.getColumn(new Column(columnName));

                        StringBuffer alter = new StringBuffer("alter table ")
                            .append(table.getQualifiedName(dialect, defaultCatalog, defaultSchema)).append(' ')
                            .append(extDialect.getAddNotNullSql(mapping, column));
                        sqlStrings.add(alter.toString());
                    }
                }
            }
            finally
            {
                colresult.close();
            }
        }
    });
    return sqlStrings;
}

private static void bindIndex(Attribute indexAttribute, Table table, Column column, Mappings mappings) {
    if ( indexAttribute != null && table != null ) {
        StringTokenizer tokens = new StringTokenizer( indexAttribute.getValue(), ", " );
        while ( tokens.hasMoreTokens() ) {
            table.getOrCreateIndex( tokens.nextToken() ).addColumn( column );
        }
    }
}

private static void bindUniqueKey(Attribute uniqueKeyAttribute, Table table, Column column, Mappings mappings) {
    if ( uniqueKeyAttribute != null && table != null ) {
        StringTokenizer tokens = new StringTokenizer( uniqueKeyAttribute.getValue(), ", " );
        while ( tokens.hasMoreTokens() ) {
            table.getOrCreateUniqueKey( tokens.nextToken() ).addColumn( column );
        }
    }
}

public static void bindColumn(Element node, Column column, boolean isNullable) throws MappingException {
    Attribute lengthNode = node.attribute( "length" );
    if ( lengthNode != null ) column.setLength( Integer.parseInt( lengthNode.getValue() ) );
    Attribute scalNode = node.attribute( "scale" );
    if ( scalNode != null ) column.setScale( Integer.parseInt( scalNode.getValue() ) );
    Attribute precNode = node.attribute( "precision" );
    if ( precNode != null ) column.setPrecision( Integer.parseInt( precNode.getValue() ) );

    Attribute nullNode = node.attribute( "not-null" );
    column.setNullable( nullNode == null ? isNullable : nullNode.getValue().equals( "false" ) );

    Attribute unqNode = node.attribute( "unique" );
    if ( unqNode != null ) column.setUnique( unqNode.getValue().equals( "true" ) );

    column.setCheckConstraint( node.attributeValue( "check" ) );
    column.setDefaultValue( node.attributeValue( "default" ) );

    Attribute typeNode = node.attribute( "sql-type" );
    if ( typeNode != null ) column.setSqlType( typeNode.getValue() );

    String customWrite = node.attributeValue( "write" );
    if(customWrite != null && !customWrite.matches("[^?]*\\?[^?]*")) {
        throw new MappingException("write expression must contain exactly one value placeholder ('?') character");
    }
    column.setCustomWrite( customWrite );
    column.setCustomRead( node.attributeValue( "read" ) );

    Element comment = node.element("comment");
    if (comment!=null) column.setComment( comment.getTextTrim() );

}