From c9204eed3f5fc7d3472434404c69559c0d4c0b7c Mon Sep 17 00:00:00 2001 From: Roland Praml Date: Tue, 15 Mar 2022 15:59:33 +0100 Subject: [PATCH] DB2: HistorySupport added --- .../dbplatform/db2/BaseDB2Platform.java | 1 + .../dbplatform/db2/DB2HistorySupport.java | 30 ++++ .../ddlgeneration/platform/BaseTableDdl.java | 10 +- .../ddlgeneration/platform/DB2Ddl.java | 30 ++++ .../ddlgeneration/platform/Db2HistoryDdl.java | 138 ++++++++++++++++++ .../dbmigration/DbMigrationTest.java | 3 + 6 files changed, 211 insertions(+), 1 deletion(-) create mode 100644 ebean-api/src/main/java/io/ebean/config/dbplatform/db2/DB2HistorySupport.java create mode 100644 ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/Db2HistoryDdl.java diff --git a/ebean-api/src/main/java/io/ebean/config/dbplatform/db2/BaseDB2Platform.java b/ebean-api/src/main/java/io/ebean/config/dbplatform/db2/BaseDB2Platform.java index 8b313d26d..2ef1488ac 100644 --- a/ebean-api/src/main/java/io/ebean/config/dbplatform/db2/BaseDB2Platform.java +++ b/ebean-api/src/main/java/io/ebean/config/dbplatform/db2/BaseDB2Platform.java @@ -36,6 +36,7 @@ public abstract class BaseDB2Platform extends DatabasePlatform { .addDataIntegrity("23502","23503","23504","23511","23512","23511","42917","23515") .build(); + historySupport = new DB2HistorySupport(); booleanDbType = Types.BOOLEAN; dbTypeMap.put(DbType.TINYINT, new DbPlatformType("smallint", false)); dbTypeMap.put(DbType.INTEGER, new DbPlatformType("integer", false)); diff --git a/ebean-api/src/main/java/io/ebean/config/dbplatform/db2/DB2HistorySupport.java b/ebean-api/src/main/java/io/ebean/config/dbplatform/db2/DB2HistorySupport.java new file mode 100644 index 000000000..122f1b57c --- /dev/null +++ b/ebean-api/src/main/java/io/ebean/config/dbplatform/db2/DB2HistorySupport.java @@ -0,0 +1,30 @@ +package io.ebean.config.dbplatform.db2; + +import io.ebean.config.dbplatform.DbStandardHistorySupport; + +/** + * DB2 based history support. + */ +public class DB2HistorySupport extends DbStandardHistorySupport { + + @Override + public String getAsOfViewSuffix(String asOfViewSuffix) { + return " for system_time as of ?"; + } + + @Override + public String getVersionsBetweenSuffix(String asOfViewSuffix) { + return " for system_time between ? and ?"; + } + + @Override + public String getSysPeriodLower(String tableAlias, String sysPeriod) { + return tableAlias + "." + sysPeriod + "_start"; + } + + @Override + public String getSysPeriodUpper(String tableAlias, String sysPeriod) { + return tableAlias + "." + sysPeriod + "_end"; + } + +} diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/BaseTableDdl.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/BaseTableDdl.java index cef2edc92..8d606abfa 100644 --- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/BaseTableDdl.java +++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/BaseTableDdl.java @@ -759,6 +759,11 @@ public class BaseTableDdl implements TableDdl { // we will apply only type changes or notNull -> null transition boolean isNull = Boolean.FALSE.equals(alter.isNotnull()); boolean applyToHistory = alter.getType() != null || isNull; + boolean syncExact = platformDdl.getPlatform().isPlatform(Platform.DB2); + // DB2 needs exact sync for notnull/null + if (syncExact && alter.isNotnull() != null) { + applyToHistory = true; + } if (applyToHistory) { platformDdl.regenerateHistoryTriggers(writer, alter.getTableName()); if (alterHistoryTables) { @@ -768,7 +773,10 @@ public class BaseTableDdl implements TableDdl { // ignore default value (not needed on history tables) alterHistoryColumn.setCurrentType(alter.getCurrentType()); alterHistoryColumn.setType(alter.getType()); - if (isNull) { + if (syncExact) { + alterHistoryColumn.setCurrentNotnull(alter.isCurrentNotnull()); + alterHistoryColumn.setNotnull(alter.isNotnull()); + } else if (isNull) { // do transition from notNull to null alterHistoryColumn.setCurrentNotnull(Boolean.TRUE); alterHistoryColumn.setNotnull(Boolean.FALSE); diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DB2Ddl.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DB2Ddl.java index cb4b3434c..c021cfdfc 100644 --- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DB2Ddl.java +++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DB2Ddl.java @@ -4,8 +4,11 @@ import java.util.ArrayList; import java.util.List; import io.ebean.config.dbplatform.DatabasePlatform; +import io.ebean.util.StringHelper; import io.ebeaninternal.dbmigration.ddlgeneration.DdlAlterTable; +import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer; import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite; +import io.ebeaninternal.dbmigration.migration.Column; /** * DB2 platform specific DDL. @@ -22,6 +25,7 @@ public class DB2Ddl extends PlatformDdl { this.columnSetNull = "drop not null"; this.columnSetType = "set data type "; this.inlineUniqueWhenNullable = false; + this.historyDdl = new Db2HistoryDdl(); } @Override @@ -46,6 +50,32 @@ public class DB2Ddl extends PlatformDdl { return sb.toString(); } + @Override + public void alterTableAddColumn(DdlWrite writer, String tableName, Column column, boolean onHistoryTable, String defaultValue) { + + String convertedType = convert(column.getType()); + DdlBuffer buffer = alterTable(writer, tableName).append(addColumn, column.getName()); + buffer.append(convertedType); + + // Add default value also to history table if it is not excluded + if (defaultValue != null) { + buffer.append(" default "); + buffer.append(defaultValue); + } + + if (isTrue(column.isNotnull())) { + buffer.appendWithSpace(columnNotNull); + } + // DB2 History table must match exact! + if (!onHistoryTable) { + // check constraints cannot be added in one statement for h2 + if (!StringHelper.isNull(column.getCheckConstraint())) { + String ddl = alterTableAddCheckConstraint(tableName, column.getCheckConstraintName(), column.getCheckConstraint()); + writer.applyPostAlter().appendStatement(ddl); + } + } + + } @Override public String alterTableDropForeignKey(String tableName, String fkName) { return alterTableDropConstraint(tableName, fkName); diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/Db2HistoryDdl.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/Db2HistoryDdl.java new file mode 100644 index 000000000..f1409974d --- /dev/null +++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/Db2HistoryDdl.java @@ -0,0 +1,138 @@ +package io.ebeaninternal.dbmigration.ddlgeneration.platform; + +import java.util.Collection; + +import io.ebean.config.DatabaseConfig; +import io.ebeaninternal.dbmigration.ddlgeneration.DdlAlterTable; +import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer; +import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite; +import io.ebeaninternal.dbmigration.migration.AddHistoryTable; +import io.ebeaninternal.dbmigration.migration.DropHistoryTable; +import io.ebeaninternal.dbmigration.model.MColumn; +import io.ebeaninternal.dbmigration.model.MTable; + +/** + * DB2 History support. + * + * @author Roland Praml, FOCONIS AG + */ +public class Db2HistoryDdl implements PlatformHistoryDdl { + + private String systemPeriodStart; + private String systemPeriodEnd; + private String transactionId; + private PlatformDdl platformDdl; + private String historySuffix; + + @Override + public void configure(DatabaseConfig config, PlatformDdl platformDdl) { + this.systemPeriodStart = config.getAsOfSysPeriod() + "_start"; + this.systemPeriodEnd = config.getAsOfSysPeriod() + "_end"; + this.transactionId = config.getAsOfSysPeriod() + "_txn"; // required for DB2 + this.platformDdl = platformDdl; + this.historySuffix = config.getHistoryTableSuffix(); + } + + @Override + public void createWithHistory(DdlWrite writer, MTable table) { + String tableName = table.getName(); + String historyTableName = tableName + historySuffix; + + DdlBuffer apply = writer.applyPostAlter(); + apply.append(platformDdl.getCreateTableCommandPrefix()).append(" ").append(historyTableName).append(" (").newLine(); + + // create history table + Collection cols = table.allColumns(); + for (MColumn column : cols) { + if (!column.isDraftOnly()) { + writeColumnDefinition(apply, column.getName(), column.getType(), column.isNotnull() || column.isPrimaryKey()); + apply.append(",").newLine(); + } + } + writeColumnDefinition(apply, systemPeriodStart, "timestamp(12)", true); + apply.append(",").newLine(); + writeColumnDefinition(apply, systemPeriodEnd, "timestamp(12)", true); + apply.append(",").newLine(); + writeColumnDefinition(apply, transactionId, "timestamp(12)", false); + apply.newLine().append(")").endOfStatement(); + + // enable system versioning + addSysPeriodColumns(writer, tableName); + enableSystemVersioning(apply, tableName); + platformDdl.alterTable(writer, tableName).setHistoryHandled(); + + // drop all: We do not drop columns here, as the whole table will be dropped + disableSystemVersioning(writer.dropAll(), tableName); + writer.dropAll().append("drop table ").append(historyTableName).endOfStatement(); + } + + void addSysPeriodColumns(DdlWrite writer, String baseTable) { + platformDdl.alterTableAddColumn(writer, baseTable, systemPeriodStart, "timestamp(12) not null generated always as row begin", null); + platformDdl.alterTableAddColumn(writer, baseTable, systemPeriodEnd, "timestamp(12) not null generated always as row end", null); + platformDdl.alterTableAddColumn(writer, baseTable, transactionId, "timestamp(12) generated always as transaction start id", null); + platformDdl.alterTable(writer, baseTable).append("add period system_time", null) + .append("(").append(systemPeriodStart).append(",").append(systemPeriodEnd).append(")"); + } + + @Override + public void dropHistoryTable(DdlWrite writer, DropHistoryTable dropHistoryTable) { + dropHistoryTable(writer, dropHistoryTable.getBaseTable(), dropHistoryTable.getBaseTable() + historySuffix); + } + + protected void dropHistoryTable(DdlWrite writer, String baseTable, String historyTable) { + disableSystemVersioning(writer.apply(), baseTable); + writer.apply().append("alter table ").append(baseTable).append(" drop period system_time").endOfStatement(); + + // drop the period & period columns + platformDdl.alterTableDropColumn(writer, baseTable, systemPeriodStart); + platformDdl.alterTableDropColumn(writer, baseTable, systemPeriodEnd); + platformDdl.alterTableDropColumn(writer, baseTable, transactionId); + + // drop the history table + writer.applyPostAlter().append("drop table ").append(historyTable).endOfStatement(); + } + + @Override + public void addHistoryTable(DdlWrite writer, AddHistoryTable addHistoryTable) { + MTable table = writer.getTable(addHistoryTable.getBaseTable()); + if (table == null) { + throw new IllegalStateException("MTable " + addHistoryTable.getBaseTable() + " not found in writer? (required for history DDL)"); + } + createWithHistory(writer, table); + } + + @Override + public boolean alterHistoryTables() { + return true; + } + + @Override + public void updateTriggers(DdlWrite writer, String tableName) { + DdlAlterTable alter = platformDdl.alterTable(writer, tableName); + MTable table = writer.getTable(tableName); + if (table.isWithHistory() && !alter.isHistoryHandled()) { + disableSystemVersioning(writer.apply(), tableName); + enableSystemVersioning(writer.applyPostAlter(), tableName); + alter.setHistoryHandled(); + } + } + + protected void writeColumnDefinition(DdlBuffer buffer, String columnName, String type, boolean isNotNull) { + + String platformType = platformDdl.convert(type); + buffer.append(" ").append(platformDdl.lowerColumnName(columnName)); + buffer.append(" ").append(platformType); + if (isNotNull) { + buffer.append(" not null"); + } + } + + public void disableSystemVersioning(DdlBuffer apply, String tableName) { + apply.append("alter table ").append(tableName).append(" drop versioning").endOfStatement(); + } + + public void enableSystemVersioning(DdlBuffer apply, String tableName) { + apply.append("alter table ").append(tableName).append(" add versioning use history table ").append(tableName).append(historySuffix).endOfStatement(); + } + +} diff --git a/ebean-test/src/test/java/io/ebeaninternal/dbmigration/DbMigrationTest.java b/ebean-test/src/test/java/io/ebeaninternal/dbmigration/DbMigrationTest.java index 7131e0a90..df309a65a 100644 --- a/ebean-test/src/test/java/io/ebeaninternal/dbmigration/DbMigrationTest.java +++ b/ebean-test/src/test/java/io/ebeaninternal/dbmigration/DbMigrationTest.java @@ -235,6 +235,9 @@ public class DbMigrationTest extends BaseTestCase { case SQLSERVER17: // these DBs are 'standard based' so they also do not support HistoryExclude case MARIADB: case HANA: + case DB2LUW: + case DB2FORI: // not yet tested + case DB2ZOS: // not yet tested assertThat(versions2.get(0).getDiff().toString()).as("using platform: %s, versions2:%s", server().platform(), versions2) .contains("testString=foo2,foo1") .contains("testString2=bar2,bar1");