Java AddColumnStatement.getColumnName方法代码示例

import liquibase.statement.core.AddColumnStatement; //导入方法依赖的package包/类
protected void addForeignKeyStatements(AddColumnStatement statement, Database database, List<Sql> returnSql) {
    for (ColumnConstraint constraint : statement.getConstraints()) {
        if (constraint instanceof ForeignKeyConstraint) {
            ForeignKeyConstraint fkConstraint = (ForeignKeyConstraint) constraint;
            Matcher referencesMatcher = Pattern.compile("([\\w\\._]+)\\(([\\w_]+)\\)").matcher(fkConstraint.getReferences());
            if (!referencesMatcher.matches()) {
                throw new UnexpectedLiquibaseException("Don't know how to find table and column names from " + fkConstraint.getReferences());
            }
            String refSchemaName = null;
            String refTableName = referencesMatcher.group(1);
            if (refTableName.indexOf(".") > 0) {
                refSchemaName = refTableName.split("\\.")[0];
                refTableName = refTableName.split("\\.")[1];
            }
            String refColName = referencesMatcher.group(2);

            AddForeignKeyConstraintStatement addForeignKeyConstraintStatement = new AddForeignKeyConstraintStatement(fkConstraint.getForeignKeyName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName(), refSchemaName, refTableName, refColName);
            returnSql.addAll(Arrays.asList(SqlGeneratorFactory.getInstance().generateSql(addForeignKeyConstraintStatement, database)));
        }
    }
}
 

import liquibase.statement.core.AddColumnStatement; //导入方法依赖的package包/类
@Override
public Sql[] generateSql(final AddColumnStatement statement,
      final Database database, final SqlGeneratorChain sqlGeneratorChain) {

   GeometryType geometryType = null;
   final LiquibaseDataType dataType = DataTypeFactory.getInstance()
         .fromDescription(statement.getColumnType(), database);
   if (dataType instanceof GeometryType) {
      geometryType = (GeometryType) dataType;
   }

   final boolean isGeometryColumn = geometryType != null;

   // The AddGeometryColumn procedure handles the column already being
   // present, so let a
   // downstream SQL generator handle the typical column addition logic (e.g.
   // placement in the
   // table) then invoke the procedure.
   final List<Sql> list = new ArrayList<Sql>();
   list.addAll(Arrays.asList(sqlGeneratorChain.generateSql(statement,
         database)));
   if (isGeometryColumn) {
      String schemaName = statement.getSchemaName();
      if (schemaName == null) {
         schemaName = database.getDefaultSchemaName();
      }
      final String tableName = statement.getTableName();
      final String columnName = statement.getColumnName();

      final int srid = geometryType.getSRID();
      final String geomType = StringUtils.trimToNull(geometryType
            .getGeometryType()) == null ? "'Geometry'" : "'"
            + database.escapeStringForDatabase(geometryType
                  .getGeometryType()) + "'";
      final String sql = "CALL AddGeometryColumn('" + schemaName + "', '"
            + tableName + "', '" + columnName + "', " + srid + ", "
            + geomType + ", 2)";
      final Sql addGeometryColumn = new UnparsedSql(sql);
      list.add(addGeometryColumn);
   }
   return list.toArray(new Sql[list.size()]);
}
 

import liquibase.statement.core.AddColumnStatement; //导入方法依赖的package包/类
@Override
    public Sql[] generateSql(AddColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
        if (!supports(statement, database)) {
            return sqlGeneratorChain.generateSql(statement, database);
        }

        String catalogName = statement.getCatalogName();
        String schemaName = statement.getSchemaName();
        if (schemaName == null) {
            schemaName = database.getDefaultSchemaName();
        }
        String tableName = statement.getTableName();
        String columnName = statement.getColumnName();
        String columnType = statement.getColumnType();

        String alterTable = "ALTER TABLE " + database.escapeTableName(catalogName, schemaName, tableName) +
                " ADD (" + database.escapeColumnName(catalogName, schemaName, tableName, columnName) +
                " " + DataTypeFactory.getInstance().fromDescription(columnType + 
                (statement.isAutoIncrement() ? "{autoIncrement:true}" : ""), database).toDatabaseDataType(database);

        if (statement.isAutoIncrement() && database.supportsAutoIncrement()) {
            AutoIncrementConstraint autoIncrementConstraint = statement.getAutoIncrementConstraint();
            alterTable += " " + database.getAutoIncrementClause(autoIncrementConstraint.getStartWith(), autoIncrementConstraint.getIncrementBy());
        }

        if (!statement.isNullable()) {
            alterTable += " NOT NULL";
        }

        if (statement.isPrimaryKey()) {
            alterTable += " PRIMARY KEY";
        }

        // "ALTER TABLE ADD COLUMN ..." does not support unique constraints in Hana
//        if (statement.isUnique()) {
//            alterTable += " UNIQUE ";
//        }

        alterTable += getDefaultClause(statement, database);

        if ( database instanceof HanaDBDatabase ) {
            alterTable += ")";
        }

        List<Sql> returnSql = new ArrayList<Sql>();
        
        // drop both incoming and outgoing foreign key constraints before adding column
        Set<ForeignKeyConstraintMetaData> constraints = SqlGeneratorHelperHanaDB.getAllForeignKeyConstraints(database, schemaName, tableName);
        SqlGeneratorHelperHanaDB.addDropForeignKeyConstraintsStatements(returnSql, database, constraints);
        
        returnSql.add(new UnparsedSql(alterTable, getAffectedColumn(statement)));
        
        // recreate foreign key constraints
        SqlGeneratorHelperHanaDB.addCreateForeignKeyConstraintsStatements(returnSql, database, constraints);

        addForeignKeyStatements(statement, database, returnSql);

        return returnSql.toArray(new Sql[returnSql.size()]);
    }