diff --git a/pom.xml b/pom.xml index 40f5d45..e851044 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ 4.0.0 liquibase netezza - 5.0.2 + 5.0.6 Liquibase Netezza Database Integration Liquibase extension for Netezza database http://www.liquibase.org @@ -139,7 +139,7 @@ - liquibase.ext.netezza.database,liquibase.ext.netezza.snapshot + liquibase.ext.netezza.sqlgenerator,liquibase.ext.netezza.datatype,liquibase.ext.netezza.change,liquibase.ext.netezza.database,liquibase.ext.netezza.snapshot,liquibase.ext.netezza.statement,liquibase.ext.netezza.diff true diff --git a/src/main/java/liquibase/ext/netezza/change/ModifyDataTypeChangeDestructiveNetezza.java b/src/main/java/liquibase/ext/netezza/change/ModifyDataTypeChangeDestructiveNetezza.java new file mode 100644 index 0000000..98c8a2b --- /dev/null +++ b/src/main/java/liquibase/ext/netezza/change/ModifyDataTypeChangeDestructiveNetezza.java @@ -0,0 +1,69 @@ +/* + * DBeaver - Universal Database Manager + * Copyright (C) 2010-2026 DBeaver Corp and others + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package liquibase.ext.netezza.change; + +import liquibase.change.DatabaseChange; +import liquibase.change.core.ModifyDataTypeChange; +import liquibase.database.Database; +import liquibase.ext.netezza.statement.ModifyColumnDataTypeStatementNetezza; +import liquibase.statement.SqlStatement; + +/** + * Netezza only allows changing length(by incrementing but not decrementing) and precision(by incrementing but not decrementing) of the data type. + * So we need to override the default implementation of ModifyDataTypeChange to generate the correct SQL + * for Netezza. If the change is not safe, we will throw an exception to prevent the change from being executed. + * This class is used to mark the change as destructive, to make it different from the default implementation of ModifyDataTypeChange which is not destructive. + */ +@DatabaseChange( + name = "modifyDataTypeDestructive", + description = "Modify the data type of a column, by recreating", + priority = 5, + appliesTo = {"column"} +) +public class ModifyDataTypeChangeDestructiveNetezza extends ModifyDataTypeChange { + + @Override + public SqlStatement[] generateStatements(Database database) { + ModifyColumnDataTypeStatementNetezza modifyDataTypeStatement = new ModifyColumnDataTypeStatementNetezza(this.getCatalogName(), this.getSchemaName(), this.getTableName(), this.getColumnName(), this.getNewDataType()); + return new SqlStatement[] {modifyDataTypeStatement}; + } + + @Override + public String getCatalogName() { + return super.getCatalogName(); + } + + @Override + public String getSchemaName() { + return super.getSchemaName(); + } + + @Override + public String getTableName() { + return super.getTableName(); + } + + @Override + public String getColumnName() { + return super.getColumnName(); + } + + @Override + public String getNewDataType() { + return super.getNewDataType(); + } +} diff --git a/src/main/java/liquibase/ext/netezza/datatype/NetezzaNumberType.java b/src/main/java/liquibase/ext/netezza/datatype/NetezzaNumberType.java new file mode 100644 index 0000000..e248ba2 --- /dev/null +++ b/src/main/java/liquibase/ext/netezza/datatype/NetezzaNumberType.java @@ -0,0 +1,36 @@ +/* + * DBeaver - Universal Database Manager + * Copyright (C) 2010-2026 DBeaver Corp and others + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package liquibase.ext.netezza.datatype; + +import liquibase.database.Database; +import liquibase.datatype.DatabaseDataType; +import liquibase.datatype.core.NumberType; +import liquibase.ext.netezza.database.NetezzaDatabase; + +public class NetezzaNumberType extends NumberType { + public int getPriority() { + return 5; + } + + public boolean supports(Database database) { + return database instanceof NetezzaDatabase; + } + + public DatabaseDataType toDatabaseDataType(Database database) { + return new DatabaseDataType("NUMERIC", this.getParameters()); + } +} diff --git a/src/main/java/liquibase/ext/netezza/diff/output/changelog/ChangedColumnChangeGeneratorNetezza.java b/src/main/java/liquibase/ext/netezza/diff/output/changelog/ChangedColumnChangeGeneratorNetezza.java new file mode 100644 index 0000000..42f9e0c --- /dev/null +++ b/src/main/java/liquibase/ext/netezza/diff/output/changelog/ChangedColumnChangeGeneratorNetezza.java @@ -0,0 +1,171 @@ +/* + * DBeaver - Universal Database Manager + * Copyright (C) 2010-2026 DBeaver Corp and others + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package liquibase.ext.netezza.diff.output.changelog; + +import liquibase.Scope; +import liquibase.change.Change; +import liquibase.database.Database; +import liquibase.database.jvm.JdbcConnection; +import liquibase.diff.Difference; +import liquibase.diff.ObjectDifferences; +import liquibase.diff.output.DiffOutputControl; +import liquibase.diff.output.changelog.core.ChangedColumnChangeGenerator; +import liquibase.ext.netezza.change.ModifyDataTypeChangeDestructiveNetezza; +import liquibase.ext.netezza.database.NetezzaDatabase; +import liquibase.structure.DatabaseObject; +import liquibase.structure.core.Column; +import liquibase.structure.core.DataType; +import liquibase.structure.core.Schema; + +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class ChangedColumnChangeGeneratorNetezza extends ChangedColumnChangeGenerator { + + public static final Pattern LENGTH_PATTERN = Pattern.compile("VARCHAR\\((\\d+)\\s*(?:BYTE)?\\)"); + + + @Override + public int getPriority(Class objectType, Database database) { + if (database instanceof NetezzaDatabase) { + return Column.class.isAssignableFrom(objectType) ? 2 : -1; + } else { + return PRIORITY_NONE; + } + } + + @Override + protected void handleTypeDifferences( + Column column, + ObjectDifferences differences, + DiffOutputControl control, + List changes, + Database referenceDatabase, + Database comparisonDatabase + ) { + Difference typeDifference = differences.getDifference("type"); + if (typeDifference == null) { + return; + } + String table = column.getRelation().getName(); + String columnName = column.getName(); + Schema schema = column.getRelation().getSchema(); + boolean isSafe = isSafeExpansion( + typeDifference.getComparedValue().toString(), + typeDifference.getReferenceValue().toString() + ); + if (!isSafe && isDistributionKey(referenceDatabase, schema, table, columnName)) { + Scope.getCurrentScope().getLog(getClass()) + .warning(String.format("Column '%s.%s.%s' is a distribution key. Full table rebuild required.", schema, table, columnName)); + return; + } + + if (!isSafe && isIndexed(referenceDatabase, schema, table, columnName)) { + Scope.getCurrentScope().getLog(getClass()).warning( + String.format( + "Column '%s.%s.%s' is indexed and cannot be safely modified in Netezza.", + schema, table, columnName + ) + ); + return; + } + if (isSafe) { + super.handleTypeDifferences(column, differences, control, changes, referenceDatabase, comparisonDatabase); + } else { + ModifyDataTypeChangeDestructiveNetezza modifyDataTypeChangeDestructiveNetezza = new ModifyDataTypeChangeDestructiveNetezza(); + modifyDataTypeChangeDestructiveNetezza.setSchemaName(schema.getName()); + modifyDataTypeChangeDestructiveNetezza.setTableName(table); + modifyDataTypeChangeDestructiveNetezza.setColumnName(columnName); + DataType referenceType = (DataType)typeDifference.getReferenceValue(); + modifyDataTypeChangeDestructiveNetezza.setNewDataType(referenceType.toString()); + changes.add(modifyDataTypeChangeDestructiveNetezza); + } + } + + private boolean isSafeExpansion(String oldType, String newType) { + if (oldType == null) return false; + + oldType = oldType.toUpperCase(); + newType = newType.toUpperCase(); + + // VARCHAR(n) -> VARCHAR(m) where m >= n + if (oldType.startsWith("VARCHAR") && newType.startsWith("VARCHAR")) { + int oldLen = extractSingleNumber(oldType); + int newLen = extractSingleNumber(newType); + return newLen >= oldLen; + } + + return false; + } + + private int extractSingleNumber(String type) { + Matcher m = LENGTH_PATTERN.matcher(type); + return m.find() ? Integer.parseInt(m.group(1)) : 0; + } + + private boolean isDistributionKey(Database referenceDatabase, Schema schema, String table, String columnName) { + String sql = + "SELECT 1\n" + + "FROM _v_table_dist_map dm\n" + + "WHERE dm.OWNER = ?\n" + + " AND dm.TABLENAME = ?\n" + + " AND dm.attname = ?"; + try (PreparedStatement ps = ((JdbcConnection) referenceDatabase.getConnection()).prepareStatement(sql)) { + ps.setString(1, schema.getName().toUpperCase()); + ps.setString(2, table.toUpperCase()); + ps.setString(3, columnName.toUpperCase()); + + try (ResultSet rs = ps.executeQuery()) { + return rs.next(); + } + + } catch (Exception e) { + throw new RuntimeException( + "Failed to check distribution key for " + table + "." + columnName, e + ); + } + } + + protected boolean isIndexed(Database database, Schema schema, String table, String column) { + String sql = + "SELECT 1\n" + + "FROM DEFINITION_SCHEMA._V_RELATION_KEYDATA\n" + + "WHERE \"SCHEMA\" = ?\n" + + " AND RELATION = ?\n" + + " AND ATTNAME = ?"; + + try (PreparedStatement ps = + ((JdbcConnection) database.getConnection()).prepareStatement(sql)) { + + ps.setString(1, schema.getName().toUpperCase()); + ps.setString(2, table.toUpperCase()); + ps.setString(3, column.toUpperCase()); + + try (ResultSet rs = ps.executeQuery()) { + return rs.next(); + } + + } catch (Exception e) { + throw new RuntimeException( + "Failed to check index usage for " + schema + "." + table + "." + column, e + ); + } + } +} diff --git a/src/main/java/liquibase/ext/netezza/sqlgenerator/DropColumnGeneratorNetezza.java b/src/main/java/liquibase/ext/netezza/sqlgenerator/DropColumnGeneratorNetezza.java new file mode 100644 index 0000000..60e5ab6 --- /dev/null +++ b/src/main/java/liquibase/ext/netezza/sqlgenerator/DropColumnGeneratorNetezza.java @@ -0,0 +1,50 @@ +/* + * DBeaver - Universal Database Manager + * Copyright (C) 2010-2026 DBeaver Corp and others + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package liquibase.ext.netezza.sqlgenerator; + +import liquibase.database.Database; +import liquibase.ext.netezza.database.NetezzaDatabase; +import liquibase.sql.Sql; +import liquibase.sql.UnparsedSql; +import liquibase.sqlgenerator.SqlGeneratorChain; +import liquibase.sqlgenerator.core.DropColumnGenerator; +import liquibase.statement.core.DropColumnStatement; +import liquibase.structure.DatabaseObject; + +public class DropColumnGeneratorNetezza extends DropColumnGenerator { + public int getPriority() { + return 5; + } + + public boolean supports(DropColumnStatement statement, Database database) { + return database instanceof NetezzaDatabase; + } + + public Sql[] generateSql(DropColumnStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) { + Sql[] sqls = new Sql[1]; + String tableName = database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName()); + sqls[0] = new UnparsedSql( + "ALTER TABLE " + tableName + " DROP " + database.escapeColumnName( + statement.getCatalogName(), + statement.getSchemaName(), + statement.getTableName(), + statement.getColumnName() + ) + " RESTRICT", new DatabaseObject[0] + ); + return sqls; + } +} diff --git a/src/main/java/liquibase/ext/netezza/sqlgenerator/ModifyDataTypeGeneratorNetezza.java b/src/main/java/liquibase/ext/netezza/sqlgenerator/ModifyDataTypeGeneratorNetezza.java new file mode 100644 index 0000000..b4bae23 --- /dev/null +++ b/src/main/java/liquibase/ext/netezza/sqlgenerator/ModifyDataTypeGeneratorNetezza.java @@ -0,0 +1,96 @@ +/* + * DBeaver - Universal Database Manager + * Copyright (C) 2010-2026 DBeaver Corp and others + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package liquibase.ext.netezza.sqlgenerator; + +import liquibase.database.Database; +import liquibase.datatype.DataTypeFactory; +import liquibase.datatype.DatabaseDataType; +import liquibase.exception.Warnings; +import liquibase.ext.netezza.database.NetezzaDatabase; +import liquibase.ext.netezza.statement.ModifyColumnDataTypeStatementNetezza; +import liquibase.sql.Sql; +import liquibase.sql.UnparsedSql; +import liquibase.sqlgenerator.SqlGeneratorChain; +import liquibase.sqlgenerator.core.ModifyDataTypeGenerator; +import liquibase.statement.core.ModifyDataTypeStatement; +import liquibase.structure.core.Relation; + +/** + * Netezza only allows changing length(by incrementing but not decrementing) and precision(by incrementing but not decrementing) of the data type. + * So we need to override the default implementation of ModifyDataTypeGenerator to generate the correct SQL for Netezza. + */ +public class ModifyDataTypeGeneratorNetezza extends ModifyDataTypeGenerator { + public ModifyDataTypeGeneratorNetezza() { + super(); + } + + @Override + public boolean supports(ModifyDataTypeStatement statement, Database database) { + if (statement instanceof ModifyColumnDataTypeStatementNetezza) { + return database instanceof NetezzaDatabase; + } else { + return false; + } + } + + @Override + public Sql[] generateSql(ModifyDataTypeStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) { + String table = database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName());; + String column = database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()); + DatabaseDataType newDataType = DataTypeFactory.getInstance().fromDescription(statement.getNewDataType(), database).toDatabaseDataType(database); + // fallback: recreate column + String tempColumn = statement.getColumnName() + "_TMP_" + System.currentTimeMillis(); + Relation affectedTable = this.getAffectedTable(statement); + return new Sql[] { + new UnparsedSql(String.format( + "ALTER TABLE %s ADD COLUMN %s %s", + table, tempColumn, newDataType + ), affectedTable + ), + new UnparsedSql(String.format( + "UPDATE %s SET %s = %s", + table, tempColumn, column + ), affectedTable + ), + new UnparsedSql(String.format( + "ALTER TABLE %s DROP COLUMN %s RESTRICT", + table, column + ), affectedTable + ), + new UnparsedSql(String.format( + "ALTER TABLE %s RENAME COLUMN %s TO %s", + table, tempColumn, column + ), affectedTable + ) + }; + + } + + @Override + public Warnings warn(ModifyDataTypeStatement modifyDataTypeStatement, Database database, SqlGeneratorChain sqlGeneratorChain) { + return new Warnings().addWarning( + "Changing data type " + + " to " + modifyDataTypeStatement.getNewDataType() + " may cause data loss. Netezza does not support shrinking data types nor changing the type itself. Migration will attempt to recreate the column, but it may fail if there are constraints or indexes on the column." + ); + } + + + @Override + public int getPriority() { + return PRIORITY_DATABASE; + } +} diff --git a/src/main/java/liquibase/ext/netezza/sqlgenerator/NetezzaIncrementVarcharSQLGenerator.java b/src/main/java/liquibase/ext/netezza/sqlgenerator/NetezzaIncrementVarcharSQLGenerator.java new file mode 100644 index 0000000..83d8ff9 --- /dev/null +++ b/src/main/java/liquibase/ext/netezza/sqlgenerator/NetezzaIncrementVarcharSQLGenerator.java @@ -0,0 +1,67 @@ +/* + * DBeaver - Universal Database Manager + * Copyright (C) 2010-2026 DBeaver Corp and others + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package liquibase.ext.netezza.sqlgenerator; + +import liquibase.database.Database; +import liquibase.datatype.DataTypeFactory; +import liquibase.datatype.DatabaseDataType; +import liquibase.ext.netezza.database.NetezzaDatabase; +import liquibase.ext.netezza.statement.ModifyColumnDataTypeStatementNetezza; +import liquibase.sql.Sql; +import liquibase.sql.UnparsedSql; +import liquibase.sqlgenerator.SqlGeneratorChain; +import liquibase.sqlgenerator.core.ModifyDataTypeGenerator; +import liquibase.statement.core.ModifyDataTypeStatement; + +/** + * Netezza only allows changing length(by incrementing but not decrementing) + * Most of other cases are covered by ModifyDataTypeGeneratorNetezza which will recreate the column, + * for the case of incrementing varchar length, we can directly modify the column without recreating it, + * so we need this generator to handle this case. + */ +public class NetezzaIncrementVarcharSQLGenerator extends ModifyDataTypeGenerator { + + @Override + public boolean supports(ModifyDataTypeStatement statement, Database database) { + if (statement instanceof ModifyColumnDataTypeStatementNetezza) { + return false; + } + return database instanceof NetezzaDatabase; + } + + @Override + public int getPriority() { + return PRIORITY_DATABASE; // higher than default + } + + @Override + public Sql[] generateSql(ModifyDataTypeStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) { + + String table = database.escapeTableName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName());; + String column = database.escapeColumnName(statement.getCatalogName(), statement.getSchemaName(), statement.getTableName(), statement.getColumnName()); + DatabaseDataType type = DataTypeFactory.getInstance().fromDescription(statement.getNewDataType(), database).toDatabaseDataType(database); + + String sql = String.format( + "ALTER TABLE %s MODIFY COLUMN (%s %s)", + table, + column, + type + ); + + return new Sql[] {new UnparsedSql(sql, this.getAffectedTable(statement))}; + } +} \ No newline at end of file diff --git a/src/main/java/liquibase/ext/netezza/statement/ModifyColumnDataTypeStatementNetezza.java b/src/main/java/liquibase/ext/netezza/statement/ModifyColumnDataTypeStatementNetezza.java new file mode 100644 index 0000000..a7262cc --- /dev/null +++ b/src/main/java/liquibase/ext/netezza/statement/ModifyColumnDataTypeStatementNetezza.java @@ -0,0 +1,31 @@ +/* + * DBeaver - Universal Database Manager + * Copyright (C) 2010-2026 DBeaver Corp and others + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package liquibase.ext.netezza.statement; + +import liquibase.statement.core.ModifyDataTypeStatement; + +public class ModifyColumnDataTypeStatementNetezza extends ModifyDataTypeStatement { + public ModifyColumnDataTypeStatementNetezza( + String catalogName, + String schemaName, + String tableName, + String columnName, + String newDataType + ) { + super(catalogName, schemaName, tableName, columnName, newDataType); + } +} diff --git a/src/main/resources/META-INF/services/liquibase.change.Change b/src/main/resources/META-INF/services/liquibase.change.Change new file mode 100644 index 0000000..daa445e --- /dev/null +++ b/src/main/resources/META-INF/services/liquibase.change.Change @@ -0,0 +1 @@ +liquibase.ext.netezza.change.ModifyDataTypeChangeDestructiveNetezza \ No newline at end of file diff --git a/src/main/resources/META-INF/services/liquibase.datatype.LiquibaseDataType b/src/main/resources/META-INF/services/liquibase.datatype.LiquibaseDataType new file mode 100644 index 0000000..4b85baa --- /dev/null +++ b/src/main/resources/META-INF/services/liquibase.datatype.LiquibaseDataType @@ -0,0 +1 @@ +liquibase.ext.netezza.datatype.NetezzaNumberType \ No newline at end of file diff --git a/src/main/resources/META-INF/services/liquibase.diff.output.changelog.ChangeGenerator b/src/main/resources/META-INF/services/liquibase.diff.output.changelog.ChangeGenerator new file mode 100644 index 0000000..caab70e --- /dev/null +++ b/src/main/resources/META-INF/services/liquibase.diff.output.changelog.ChangeGenerator @@ -0,0 +1 @@ +liquibase.ext.netezza.diff.output.changelog.ChangedColumnChangeGeneratorNetezza \ No newline at end of file diff --git a/src/main/resources/META-INF/services/liquibase.sqlgenerator.SqlGenerator b/src/main/resources/META-INF/services/liquibase.sqlgenerator.SqlGenerator new file mode 100644 index 0000000..fbb9cb8 --- /dev/null +++ b/src/main/resources/META-INF/services/liquibase.sqlgenerator.SqlGenerator @@ -0,0 +1,3 @@ +liquibase.ext.netezza.sqlgenerator.ModifyDataTypeGeneratorNetezza +liquibase.ext.netezza.sqlgenerator.NetezzaIncrementVarcharSQLGenerator +liquibase.ext.netezza.sqlgenerator.DropColumnGeneratorNetezza diff --git a/src/main/resources/META-INF/services/liquibase.statement.SqlStatement b/src/main/resources/META-INF/services/liquibase.statement.SqlStatement new file mode 100644 index 0000000..d614df8 --- /dev/null +++ b/src/main/resources/META-INF/services/liquibase.statement.SqlStatement @@ -0,0 +1 @@ +liquibase.ext.netezza.statement.ModifyColumnDataTypeStatementNetezza \ No newline at end of file