Search in sources :

Example 1 with NotNullConstraint

use of liquibase.statement.NotNullConstraint in project liquibase by liquibase.

the class RenameColumnExecuteTest method setupStatements.

@Override
protected List<? extends SqlStatement> setupStatements(Database database) {
    ArrayList<CreateTableStatement> statements = new ArrayList<CreateTableStatement>();
    CreateTableStatement table = new CreateTableStatement(null, null, TABLE_NAME);
    if (database instanceof MySQLDatabase) {
        table.addPrimaryKeyColumn("id", DataTypeFactory.getInstance().fromDescription("int", database), null, "pk_", null);
    } else {
        table.addColumn("id", DataTypeFactory.getInstance().fromDescription("int", database), null, new ColumnConstraint[] { new NotNullConstraint() });
    }
    table.addColumn(COLUMN_NAME, DataTypeFactory.getInstance().fromDescription("int", database));
    statements.add(table);
    // }
    return statements;
}
Also used : CreateTableStatement(liquibase.statement.core.CreateTableStatement) ArrayList(java.util.ArrayList) NotNullConstraint(liquibase.statement.NotNullConstraint)

Example 2 with NotNullConstraint

use of liquibase.statement.NotNullConstraint in project liquibase by liquibase.

the class CreateDatabaseChangeLogTableGenerator method generateSql.

@Override
public Sql[] generateSql(CreateDatabaseChangeLogTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
    String charTypeName = getCharTypeName(database);
    String dateTimeTypeString = getDateTimeTypeString(database);
    CreateTableStatement createTableStatement = new CreateTableStatement(database.getLiquibaseCatalogName(), database.getLiquibaseSchemaName(), database.getDatabaseChangeLogTableName()).setTablespace(database.getLiquibaseTablespaceName()).addColumn("ID", DataTypeFactory.getInstance().fromDescription(charTypeName + "(" + getIdColumnSize() + ")", database), null, null, new NotNullConstraint()).addColumn("AUTHOR", DataTypeFactory.getInstance().fromDescription(charTypeName + "(" + getAuthorColumnSize() + ")", database), null, null, new NotNullConstraint()).addColumn("FILENAME", DataTypeFactory.getInstance().fromDescription(charTypeName + "(" + getFilenameColumnSize() + ")", database), null, null, new NotNullConstraint()).addColumn("DATEEXECUTED", DataTypeFactory.getInstance().fromDescription(dateTimeTypeString, database), null, null, new NotNullConstraint()).addColumn("ORDEREXECUTED", DataTypeFactory.getInstance().fromDescription("int", database), null, null, new NotNullConstraint()).addColumn("EXECTYPE", DataTypeFactory.getInstance().fromDescription(charTypeName + "(10)", database), null, null, new NotNullConstraint()).addColumn("MD5SUM", DataTypeFactory.getInstance().fromDescription(charTypeName + "(35)", database)).addColumn("DESCRIPTION", DataTypeFactory.getInstance().fromDescription(charTypeName + "(255)", database)).addColumn("COMMENTS", DataTypeFactory.getInstance().fromDescription(charTypeName + "(255)", database)).addColumn("TAG", DataTypeFactory.getInstance().fromDescription(charTypeName + "(255)", database)).addColumn("LIQUIBASE", DataTypeFactory.getInstance().fromDescription(charTypeName + "(20)", database)).addColumn("CONTEXTS", DataTypeFactory.getInstance().fromDescription(charTypeName + "(" + getContextsSize() + ")", database)).addColumn("LABELS", DataTypeFactory.getInstance().fromDescription(charTypeName + "(" + getLabelsSize() + ")", database)).addColumn("DEPLOYMENT_ID", DataTypeFactory.getInstance().fromDescription(charTypeName + "(10)", database));
    // use LEGACY quoting since we're dealing with system objects
    ObjectQuotingStrategy currentStrategy = database.getObjectQuotingStrategy();
    database.setObjectQuotingStrategy(ObjectQuotingStrategy.LEGACY);
    try {
        return SqlGeneratorFactory.getInstance().generateSql(createTableStatement, database);
    } finally {
        database.setObjectQuotingStrategy(currentStrategy);
    }
}
Also used : CreateTableStatement(liquibase.statement.core.CreateTableStatement) ObjectQuotingStrategy(liquibase.database.ObjectQuotingStrategy) NotNullConstraint(liquibase.statement.NotNullConstraint)

Example 3 with NotNullConstraint

use of liquibase.statement.NotNullConstraint in project liquibase by liquibase.

the class CreateTableGenerator method generateSql.

@Override
public Sql[] generateSql(CreateTableStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
    List<Sql> additionalSql = new ArrayList<>();
    StringBuilder buffer = new StringBuilder();
    buffer.append("CREATE TABLE ").append(database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())).append(" ");
    buffer.append("(");
    boolean isSinglePrimaryKeyColumn = (statement.getPrimaryKeyConstraint() != null) && (statement.getPrimaryKeyConstraint().getColumns().size() == 1);
    boolean isPrimaryKeyAutoIncrement = false;
    Iterator<String> columnIterator = statement.getColumns().iterator();
    BigInteger mysqlTableOptionStartWith = null;
    /* We have reached the point after "CREATE TABLE ... (" and will now iterate through the column list. */
    while (columnIterator.hasNext()) {
        String column = columnIterator.next();
        DatabaseDataType columnType = null;
        if (statement.getColumnTypes().get(column) != null) {
            columnType = statement.getColumnTypes().get(column).toDatabaseDataType(database);
        }
        if (columnType == null) {
            buffer.append(database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), column, false));
        } else {
            buffer.append(database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), column, !statement.isComputed(column)));
            buffer.append(" ").append(columnType);
        }
        AutoIncrementConstraint autoIncrementConstraint = null;
        for (AutoIncrementConstraint currentAutoIncrementConstraint : statement.getAutoIncrementConstraints()) {
            if (column.equals(currentAutoIncrementConstraint.getColumnName())) {
                autoIncrementConstraint = currentAutoIncrementConstraint;
                break;
            }
        }
        boolean isAutoIncrementColumn = autoIncrementConstraint != null;
        boolean isPrimaryKeyColumn = (statement.getPrimaryKeyConstraint() != null) && statement.getPrimaryKeyConstraint().getColumns().contains(column);
        isPrimaryKeyAutoIncrement = isPrimaryKeyAutoIncrement || (isPrimaryKeyColumn && isAutoIncrementColumn);
        if ((database instanceof SQLiteDatabase) && isSinglePrimaryKeyColumn && isPrimaryKeyColumn && isAutoIncrementColumn) {
            String pkName = StringUtil.trimToNull(statement.getPrimaryKeyConstraint().getConstraintName());
            if (pkName == null) {
                pkName = database.generatePrimaryKeyName(statement.getTableName());
            }
            if (pkName != null) {
                buffer.append(" CONSTRAINT ");
                buffer.append(database.escapeConstraintName(pkName));
            }
            buffer.append(" PRIMARY KEY");
        }
        // for the serial data type in postgres, there should be no default value
        if (columnType != null && !columnType.isAutoIncrement() && (statement.getDefaultValue(column) != null)) {
            Object defaultValue = statement.getDefaultValue(column);
            if (database instanceof MSSQLDatabase) {
                String constraintName = statement.getDefaultValueConstraintName(column);
                if (constraintName == null) {
                    constraintName = ((MSSQLDatabase) database).generateDefaultConstraintName(statement.getTableName(), column);
                }
                buffer.append(" CONSTRAINT ").append(database.escapeObjectName(constraintName, ForeignKey.class));
            }
            if (((database instanceof OracleDatabase) || (database instanceof PostgresDatabase)) && statement.getDefaultValue(column).toString().startsWith("GENERATED ALWAYS ")) {
                buffer.append(" ");
            } else if (database instanceof Db2zDatabase && statement.getDefaultValue(column).toString().contains("CURRENT TIMESTAMP") || statement.getDefaultValue(column).toString().contains("IDENTITY GENERATED BY DEFAULT")) {
                buffer.append(" ");
            } else {
                buffer.append(" DEFAULT ");
            }
            if (defaultValue instanceof DatabaseFunction) {
                buffer.append(database.generateDatabaseFunctionValue((DatabaseFunction) defaultValue));
            } else if (database instanceof Db2zDatabase) {
                if (statement.getDefaultValue(column).toString().contains("CURRENT TIMESTAMP")) {
                    buffer.append("");
                }
                if (statement.getDefaultValue(column).toString().contains("IDENTITY GENERATED BY DEFAULT")) {
                    buffer.append("GENERATED BY DEFAULT AS IDENTITY");
                }
                if (statement.getDefaultValue(column).toString().contains("CURRENT USER")) {
                    buffer.append("SESSION_USER ");
                }
                if (statement.getDefaultValue(column).toString().contains("CURRENT SQLID")) {
                    buffer.append("CURRENT SQLID ");
                }
            } else {
                buffer.append(statement.getColumnTypes().get(column).objectToSql(defaultValue, database));
            }
        }
        if (isAutoIncrementColumn) {
            if (database instanceof PostgresDatabase && buffer.toString().toLowerCase().endsWith("serial")) {
            // don't add more info
            } else if (database.supportsAutoIncrement()) {
                // TODO: check if database supports auto increment on non primary key column
                String autoIncrementClause = database.getAutoIncrementClause(autoIncrementConstraint.getStartWith(), autoIncrementConstraint.getIncrementBy(), autoIncrementConstraint.getGenerationType(), autoIncrementConstraint.getDefaultOnNull());
                if (!"".equals(autoIncrementClause)) {
                    buffer.append(" ").append(autoIncrementClause);
                }
                if (autoIncrementConstraint.getStartWith() != null) {
                    if (database instanceof PostgresDatabase) {
                        int majorVersion = 9;
                        try {
                            majorVersion = database.getDatabaseMajorVersion();
                        } catch (DatabaseException e) {
                        // ignore
                        }
                        if (majorVersion < 10) {
                            String sequenceName = statement.getTableName() + "_" + column + "_seq";
                            additionalSql.add(new UnparsedSql("alter sequence " + database.escapeSequenceName(statement.getCatalogName(), statement.getSchemaName(), sequenceName) + " start with " + autoIncrementConstraint.getStartWith(), new Sequence().setName(sequenceName).setSchema(statement.getCatalogName(), statement.getSchemaName())));
                        }
                    } else if (database instanceof MySQLDatabase) {
                        mysqlTableOptionStartWith = autoIncrementConstraint.getStartWith();
                    }
                }
            } else {
                Scope.getCurrentScope().getLog(getClass()).warning(database.getShortName() + " does not support autoincrement columns as requested for " + (database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName())));
            }
        }
        // Do we have a NOT NULL constraint for this column?
        if (statement.getNotNullColumns().get(column) != null) {
            if (!database.supportsNotNullConstraintNames()) {
                buffer.append(" NOT NULL");
            } else {
                /* Determine if the NOT NULL constraint has a name. */
                NotNullConstraint nnConstraintForThisColumn = statement.getNotNullColumns().get(column);
                String nncName = StringUtil.trimToNull(nnConstraintForThisColumn.getConstraintName());
                if (nncName == null) {
                    buffer.append(" NOT NULL");
                } else {
                    buffer.append(" CONSTRAINT ");
                    buffer.append(database.escapeConstraintName(nncName));
                    buffer.append(" NOT NULL");
                }
                if (!nnConstraintForThisColumn.shouldValidateNullable()) {
                    if (database instanceof OracleDatabase) {
                        buffer.append(" ENABLE NOVALIDATE ");
                    }
                }
            }
        // does the DB support constraint names?
        } else {
            if (columnType != null && ((database instanceof SybaseDatabase) || (database instanceof SybaseASADatabase) || (database instanceof MySQLDatabase) || ((database instanceof MSSQLDatabase) && columnType.toString().toLowerCase().contains("timestamp")))) {
                buffer.append(" NULL");
            }
        // Do we need to specify NULL explicitly?
        }
        if ((database instanceof MySQLDatabase) && (statement.getColumnRemarks(column) != null)) {
            buffer.append(" COMMENT '" + database.escapeStringForDatabase(statement.getColumnRemarks(column)) + "'");
        }
        if (columnIterator.hasNext()) {
            buffer.append(", ");
        }
    }
    buffer.append(",");
    if (!((database instanceof SQLiteDatabase) && isSinglePrimaryKeyColumn && isPrimaryKeyAutoIncrement)) {
        if ((statement.getPrimaryKeyConstraint() != null) && !statement.getPrimaryKeyConstraint().getColumns().isEmpty()) {
            if (database.supportsPrimaryKeyNames()) {
                String pkName = StringUtil.trimToNull(statement.getPrimaryKeyConstraint().getConstraintName());
                if (pkName == null) {
                    // TODO ORA-00972: identifier is too long
                    // If tableName lenght is more then 28 symbols
                    // then generated pkName will be incorrect
                    pkName = database.generatePrimaryKeyName(statement.getTableName());
                }
                if (pkName != null) {
                    buffer.append(" CONSTRAINT ");
                    buffer.append(database.escapeConstraintName(pkName));
                }
            }
            buffer.append(" PRIMARY KEY (");
            buffer.append(database.escapeColumnNameList(StringUtil.join(statement.getPrimaryKeyConstraint().getColumns(), ", ")));
            buffer.append(")");
            // Setting up table space for PK's index if it exist
            if (((database instanceof OracleDatabase) || (database instanceof PostgresDatabase)) && (statement.getPrimaryKeyConstraint().getTablespace() != null)) {
                buffer.append(" USING INDEX TABLESPACE ");
                buffer.append(statement.getPrimaryKeyConstraint().getTablespace());
            }
            buffer.append(!statement.getPrimaryKeyConstraint().shouldValidatePrimaryKey() ? " ENABLE NOVALIDATE " : "");
            if (database.supportsInitiallyDeferrableColumns()) {
                if (statement.getPrimaryKeyConstraint().isInitiallyDeferred()) {
                    buffer.append(" INITIALLY DEFERRED");
                }
                if (statement.getPrimaryKeyConstraint().isDeferrable()) {
                    buffer.append(" DEFERRABLE");
                }
            }
            buffer.append(",");
        }
    }
    for (ForeignKeyConstraint fkConstraint : statement.getForeignKeyConstraints()) {
        if (!(database instanceof InformixDatabase)) {
            buffer.append(" CONSTRAINT ");
            buffer.append(database.escapeConstraintName(fkConstraint.getForeignKeyName()));
        }
        String referencesString = fkConstraint.getReferences();
        buffer.append(" FOREIGN KEY (").append(database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), fkConstraint.getColumn())).append(") REFERENCES ");
        if (referencesString != null) {
            if (!referencesString.contains(".") && (database.getDefaultSchemaName() != null) && database.getOutputDefaultSchema()) {
                referencesString = database.escapeObjectName(database.getDefaultSchemaName(), Schema.class) + "." + referencesString;
            }
            buffer.append(referencesString);
        } else {
            buffer.append(database.escapeObjectName(fkConstraint.getReferencedTableCatalogName(), fkConstraint.getReferencedTableSchemaName(), fkConstraint.getReferencedTableName(), Table.class)).append("(").append(database.escapeColumnNameList(fkConstraint.getReferencedColumnNames())).append(")");
        }
        if (fkConstraint.isDeleteCascade()) {
            buffer.append(" ON DELETE CASCADE");
        }
        if ((database instanceof InformixDatabase)) {
            buffer.append(" CONSTRAINT ");
            buffer.append(database.escapeConstraintName(fkConstraint.getForeignKeyName()));
        }
        if (fkConstraint.isInitiallyDeferred()) {
            buffer.append(" INITIALLY DEFERRED");
        }
        if (fkConstraint.isDeferrable()) {
            buffer.append(" DEFERRABLE");
        }
        if (database instanceof OracleDatabase) {
            buffer.append(!fkConstraint.shouldValidateForeignKey() ? " ENABLE NOVALIDATE " : "");
        }
        buffer.append(",");
    }
    /*
         * In the current syntax, UNIQUE constraints can only be set per column on table creation.
         * To alleviate this problem we combine the columns of unique constraints that have the same name.
         */
    LinkedHashMap<String, UniqueConstraint> namedUniqueConstraints = new LinkedHashMap<>();
    List<UniqueConstraint> unnamedUniqueConstraints = new LinkedList<>();
    for (UniqueConstraint uniqueConstraint : statement.getUniqueConstraints()) {
        if (uniqueConstraint.getConstraintName() == null) {
            // Only combine uniqueConstraints that have a name.
            unnamedUniqueConstraints.add(uniqueConstraint);
        } else {
            String constraintName = uniqueConstraint.getConstraintName();
            UniqueConstraint existingConstraint = namedUniqueConstraints.get(constraintName);
            if (existingConstraint != null) {
                if (uniqueConstraint.shouldValidateUnique()) {
                    // if validateUnique = true on only one column, make sure it is true
                    existingConstraint.setValidateUnique(true);
                }
                existingConstraint.getColumns().addAll(uniqueConstraint.getColumns());
            } else {
                // if we haven't seen the constraint before put it in the map.
                namedUniqueConstraints.put(constraintName, uniqueConstraint);
            }
        }
    }
    unnamedUniqueConstraints.addAll(namedUniqueConstraints.values());
    for (UniqueConstraint uniqueConstraint : unnamedUniqueConstraints) {
        if (uniqueConstraint.getConstraintName() != null) {
            buffer.append(" CONSTRAINT ");
            buffer.append(database.escapeConstraintName(uniqueConstraint.getConstraintName()));
        }
        buffer.append(" UNIQUE (");
        buffer.append(database.escapeColumnNameList(StringUtil.join(uniqueConstraint.getColumns(), ", ")));
        buffer.append(")");
        if (database instanceof OracleDatabase) {
            buffer.append(!uniqueConstraint.shouldValidateUnique() ? " ENABLE NOVALIDATE " : "");
        }
        buffer.append(",");
    }
    /*
         * Here, the list of columns and constraints in the form
         * ( column1, ..., columnN, constraint1, ..., constraintN,
         * ends. We cannot leave an expression like ", )", so we remove the last comma.
         */
    String sql = buffer.toString().replaceFirst(",\\s*$", "") + ")";
    if ((database instanceof MySQLDatabase) && (mysqlTableOptionStartWith != null)) {
        Scope.getCurrentScope().getLog(getClass()).info("[MySQL] Using last startWith statement (" + mysqlTableOptionStartWith.toString() + ") as table option.");
        sql += " " + ((MySQLDatabase) database).getTableOptionAutoIncrementStartWithClause(mysqlTableOptionStartWith);
    }
    if ((statement.getTablespace() != null) && database.supportsTablespaces()) {
        if ((database instanceof MSSQLDatabase) || (database instanceof SybaseASADatabase)) {
            sql += " ON " + statement.getTablespace();
        } else if ((database instanceof AbstractDb2Database) || (database instanceof InformixDatabase)) {
            sql += " IN " + statement.getTablespace();
        } else {
            sql += " TABLESPACE " + statement.getTablespace();
        }
    }
    if ((database instanceof MySQLDatabase) && (statement.getRemarks() != null)) {
        sql += " COMMENT='" + database.escapeStringForDatabase(statement.getRemarks()) + "' ";
    }
    additionalSql.add(0, new UnparsedSql(sql, getAffectedTable(statement)));
    return additionalSql.toArray(new Sql[additionalSql.size()]);
}
Also used : DatabaseFunction(liquibase.statement.DatabaseFunction) AbstractDb2Database(liquibase.database.core.AbstractDb2Database) ForeignKeyConstraint(liquibase.statement.ForeignKeyConstraint) Schema(liquibase.structure.core.Schema) UniqueConstraint(liquibase.statement.UniqueConstraint) InformixDatabase(liquibase.database.core.InformixDatabase) DatabaseDataType(liquibase.datatype.DatabaseDataType) MSSQLDatabase(liquibase.database.core.MSSQLDatabase) NotNullConstraint(liquibase.statement.NotNullConstraint) AutoIncrementConstraint(liquibase.statement.AutoIncrementConstraint) UnparsedSql(liquibase.sql.UnparsedSql) MySQLDatabase(liquibase.database.core.MySQLDatabase) Sequence(liquibase.structure.core.Sequence) ForeignKey(liquibase.structure.core.ForeignKey) Sql(liquibase.sql.Sql) UnparsedSql(liquibase.sql.UnparsedSql) OracleDatabase(liquibase.database.core.OracleDatabase) SybaseASADatabase(liquibase.database.core.SybaseASADatabase) PostgresDatabase(liquibase.database.core.PostgresDatabase) SybaseDatabase(liquibase.database.core.SybaseDatabase) SQLiteDatabase(liquibase.database.core.SQLiteDatabase) Db2zDatabase(liquibase.database.core.Db2zDatabase) BigInteger(java.math.BigInteger) DatabaseException(liquibase.exception.DatabaseException)

Example 4 with NotNullConstraint

use of liquibase.statement.NotNullConstraint in project liquibase by liquibase.

the class AddColumnGeneratorTest method testAddMultipleColumnsMySql.

@Test
public void testAddMultipleColumnsMySql() {
    AddColumnStatement columns = new AddColumnStatement(new AddColumnStatement(null, null, TABLE_NAME, "column1", "INT", null, new NotNullConstraint()), new AddColumnStatement(null, null, TABLE_NAME, "column2", "INT", null, new NotNullConstraint()));
    assertFalse(generatorUnderTest.validate(columns, new MySQLDatabase(), new MockSqlGeneratorChain()).hasErrors());
    Sql[] sql = generatorUnderTest.generateSql(columns, new MySQLDatabase(), new MockSqlGeneratorChain());
    assertEquals(1, sql.length);
    assertEquals("ALTER TABLE " + TABLE_NAME + " ADD column1 INT NOT NULL, ADD column2 INT NOT NULL", sql[0].toSql());
    List<String> actualNames = sql[0].getAffectedDatabaseObjects().stream().map(o -> o.toString()).collect(Collectors.toList());
    List<String> expectedNames = Arrays.asList(new String[] { "table_name.column1", "table_name.column2", "table_name", "DEFAULT" });
    assertTrue(actualNames.containsAll(expectedNames));
    assertTrue(expectedNames.containsAll(actualNames));
}
Also used : liquibase.database.core(liquibase.database.core) Arrays(java.util.Arrays) SqlGeneratorFactory(liquibase.sqlgenerator.SqlGeneratorFactory) MockSqlGeneratorChain(liquibase.sqlgenerator.MockSqlGeneratorChain) AddColumnConfig(liquibase.change.AddColumnConfig) SqlGenerator(liquibase.sqlgenerator.SqlGenerator) Test(org.junit.Test) PrimaryKeyConstraint(liquibase.statement.PrimaryKeyConstraint) AddColumnChange(liquibase.change.core.AddColumnChange) Collectors(java.util.stream.Collectors) Sql(liquibase.sql.Sql) List(java.util.List) AutoIncrementConstraint(liquibase.statement.AutoIncrementConstraint) SqlStatement(liquibase.statement.SqlStatement) AddColumnStatement(liquibase.statement.core.AddColumnStatement) AbstractSqlGeneratorTest(liquibase.sqlgenerator.AbstractSqlGeneratorTest) ConstraintsConfig(liquibase.change.ConstraintsConfig) NotNullConstraint(liquibase.statement.NotNullConstraint) Assert(org.junit.Assert) AddColumnStatement(liquibase.statement.core.AddColumnStatement) NotNullConstraint(liquibase.statement.NotNullConstraint) MockSqlGeneratorChain(liquibase.sqlgenerator.MockSqlGeneratorChain) Sql(liquibase.sql.Sql) Test(org.junit.Test) AbstractSqlGeneratorTest(liquibase.sqlgenerator.AbstractSqlGeneratorTest)

Example 5 with NotNullConstraint

use of liquibase.statement.NotNullConstraint in project liquibase by liquibase.

the class AddLookupTableChange method generateStatements.

@Override
public SqlStatement[] generateStatements(Database database) {
    List<SqlStatement> statements = new ArrayList<>();
    String newTableCatalogName = getNewTableCatalogName();
    String newTableSchemaName = getNewTableSchemaName();
    String existingTableCatalogName = getExistingTableCatalogName();
    String existingTableSchemaName = getExistingTableSchemaName();
    SqlStatement[] createTablesSQL = { new RawSqlStatement("CREATE TABLE " + database.escapeTableName(newTableCatalogName, newTableSchemaName, getNewTableName()) + " AS SELECT DISTINCT " + database.escapeObjectName(getExistingColumnName(), Column.class) + " AS " + database.escapeObjectName(getNewColumnName(), Column.class) + " FROM " + database.escapeTableName(existingTableCatalogName, existingTableSchemaName, getExistingTableName()) + " WHERE " + database.escapeObjectName(getExistingColumnName(), Column.class) + " IS NOT NULL") };
    if (database instanceof MSSQLDatabase) {
        createTablesSQL = new SqlStatement[] { new RawSqlStatement("SELECT DISTINCT " + database.escapeObjectName(getExistingColumnName(), Column.class) + " AS " + database.escapeObjectName(getNewColumnName(), Column.class) + " INTO " + database.escapeTableName(newTableCatalogName, newTableSchemaName, getNewTableName()) + " FROM " + database.escapeTableName(existingTableCatalogName, existingTableSchemaName, getExistingTableName()) + " WHERE " + database.escapeObjectName(getExistingColumnName(), Column.class) + " IS NOT NULL") };
    } else if (database instanceof SybaseASADatabase) {
        createTablesSQL = new SqlStatement[] { new RawSqlStatement("SELECT DISTINCT " + database.escapeObjectName(getExistingColumnName(), Column.class) + " AS " + database.escapeObjectName(getNewColumnName(), Column.class) + " INTO " + database.escapeTableName(newTableCatalogName, newTableSchemaName, getNewTableName()) + " FROM " + database.escapeTableName(existingTableCatalogName, existingTableSchemaName, getExistingTableName()) + " WHERE " + database.escapeObjectName(getExistingColumnName(), Column.class) + " IS NOT NULL") };
    } else if (database instanceof Db2zDatabase) {
        CreateTableStatement tableStatement = new CreateTableStatement(newTableCatalogName, newTableSchemaName, getNewTableName());
        if (getNewColumnName() != null) {
            tableStatement.addColumn(getNewColumnName(), DataTypeFactory.getInstance().fromDescription(getNewColumnDataType(), database));
            tableStatement.addColumnConstraint(new NotNullConstraint(getNewColumnName()));
        }
        createTablesSQL = new SqlStatement[] { tableStatement, new RawSqlStatement("INSERT INTO " + database.escapeTableName(newTableCatalogName, newTableSchemaName, getNewTableName()) + " SELECT DISTINCT " + database.escapeObjectName(getExistingColumnName(), Column.class) + " FROM " + database.escapeTableName(existingTableCatalogName, existingTableSchemaName, getExistingTableName()) + " WHERE " + database.escapeObjectName(getExistingColumnName(), Column.class) + " IS NOT NULL") };
    } else if (database instanceof DB2Database) {
        createTablesSQL = new SqlStatement[] { new RawSqlStatement("CREATE TABLE " + database.escapeTableName(newTableCatalogName, newTableSchemaName, getNewTableName()) + " AS (SELECT " + database.escapeObjectName(getExistingColumnName(), Column.class) + " AS " + database.escapeObjectName(getNewColumnName(), Column.class) + " FROM " + database.escapeTableName(existingTableCatalogName, existingTableSchemaName, getExistingTableName()) + ") WITH NO DATA"), new RawSqlStatement("INSERT INTO " + database.escapeTableName(newTableCatalogName, newTableSchemaName, getNewTableName()) + " SELECT DISTINCT " + database.escapeObjectName(getExistingColumnName(), Column.class) + " FROM " + database.escapeTableName(existingTableCatalogName, existingTableSchemaName, getExistingTableName()) + " WHERE " + database.escapeObjectName(getExistingColumnName(), Column.class) + " IS NOT NULL") };
    } else if (database instanceof InformixDatabase) {
        createTablesSQL = new SqlStatement[] { new RawSqlStatement("CREATE TABLE " + database.escapeTableName(newTableCatalogName, newTableSchemaName, getNewTableName()) + " ( " + database.escapeObjectName(getNewColumnName(), Column.class) + " " + getNewColumnDataType() + " )"), new RawSqlStatement("INSERT INTO " + database.escapeTableName(newTableCatalogName, newTableSchemaName, getNewTableName()) + " ( " + database.escapeObjectName(getNewColumnName(), Column.class) + " ) SELECT DISTINCT " + database.escapeObjectName(getExistingColumnName(), Column.class) + " FROM " + database.escapeTableName(existingTableCatalogName, existingTableSchemaName, getExistingTableName()) + " WHERE " + database.escapeObjectName(getExistingColumnName(), Column.class) + " IS NOT NULL") };
    }
    statements.addAll(Arrays.asList(createTablesSQL));
    if (!(database instanceof OracleDatabase) && !(database instanceof Db2zDatabase)) {
        AddNotNullConstraintChange addNotNullChange = new AddNotNullConstraintChange();
        addNotNullChange.setSchemaName(newTableSchemaName);
        addNotNullChange.setTableName(getNewTableName());
        addNotNullChange.setColumnName(getNewColumnName());
        addNotNullChange.setColumnDataType(getNewColumnDataType());
        statements.addAll(Arrays.asList(addNotNullChange.generateStatements(database)));
    }
    if (database instanceof DB2Database) {
        statements.add(new ReorganizeTableStatement(newTableCatalogName, newTableSchemaName, getNewTableName()));
    }
    AddPrimaryKeyChange addPKChange = new AddPrimaryKeyChange();
    addPKChange.setSchemaName(newTableSchemaName);
    addPKChange.setTableName(getNewTableName());
    addPKChange.setColumnNames(getNewColumnName());
    statements.addAll(Arrays.asList(addPKChange.generateStatements(database)));
    if (database instanceof DB2Database) {
        statements.add(new ReorganizeTableStatement(newTableCatalogName, newTableSchemaName, getNewTableName()));
    }
    AddForeignKeyConstraintChange addFKChange = new AddForeignKeyConstraintChange();
    addFKChange.setBaseTableSchemaName(existingTableSchemaName);
    addFKChange.setBaseTableName(getExistingTableName());
    addFKChange.setBaseColumnNames(getExistingColumnName());
    addFKChange.setReferencedTableSchemaName(newTableSchemaName);
    addFKChange.setReferencedTableName(getNewTableName());
    addFKChange.setReferencedColumnNames(getNewColumnName());
    addFKChange.setConstraintName(getFinalConstraintName());
    statements.addAll(Arrays.asList(addFKChange.generateStatements(database)));
    return statements.toArray(new SqlStatement[statements.size()]);
}
Also used : RawSqlStatement(liquibase.statement.core.RawSqlStatement) DB2Database(liquibase.database.core.DB2Database) ReorganizeTableStatement(liquibase.statement.core.ReorganizeTableStatement) CreateTableStatement(liquibase.statement.core.CreateTableStatement) ArrayList(java.util.ArrayList) SybaseASADatabase(liquibase.database.core.SybaseASADatabase) OracleDatabase(liquibase.database.core.OracleDatabase) RawSqlStatement(liquibase.statement.core.RawSqlStatement) SqlStatement(liquibase.statement.SqlStatement) InformixDatabase(liquibase.database.core.InformixDatabase) Column(liquibase.structure.core.Column) Db2zDatabase(liquibase.database.core.Db2zDatabase) MSSQLDatabase(liquibase.database.core.MSSQLDatabase) NotNullConstraint(liquibase.statement.NotNullConstraint)

Aggregations

NotNullConstraint (liquibase.statement.NotNullConstraint)9 CreateTableStatement (liquibase.statement.core.CreateTableStatement)6 ArrayList (java.util.ArrayList)4 Sql (liquibase.sql.Sql)3 ObjectQuotingStrategy (liquibase.database.ObjectQuotingStrategy)2 Db2zDatabase (liquibase.database.core.Db2zDatabase)2 InformixDatabase (liquibase.database.core.InformixDatabase)2 MSSQLDatabase (liquibase.database.core.MSSQLDatabase)2 OracleDatabase (liquibase.database.core.OracleDatabase)2 SybaseASADatabase (liquibase.database.core.SybaseASADatabase)2 AbstractSqlGeneratorTest (liquibase.sqlgenerator.AbstractSqlGeneratorTest)2 MockSqlGeneratorChain (liquibase.sqlgenerator.MockSqlGeneratorChain)2 AutoIncrementConstraint (liquibase.statement.AutoIncrementConstraint)2 SqlStatement (liquibase.statement.SqlStatement)2 AddColumnStatement (liquibase.statement.core.AddColumnStatement)2 BigInteger (java.math.BigInteger)1 Arrays (java.util.Arrays)1 List (java.util.List)1 Collectors (java.util.stream.Collectors)1 AddColumnConfig (liquibase.change.AddColumnConfig)1