diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/DdlAlterTable.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/DdlAlterTable.java
new file mode 100644
index 000000000..c59666599
--- /dev/null
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/DdlAlterTable.java
@@ -0,0 +1,45 @@
+package io.ebeaninternal.dbmigration.ddlgeneration;
+
+import java.io.IOException;
+
+/**
+ * Object that represents an Alter Table statements. Table alters are grouped together by tableName in DDL and can be extended by
+ * a ddl-specific handler (e.g. doing a reorg for DB2 or implement special grouping for Hana). There is one instance per table.
+ *
+ * @author TODO Roland Praml, FOCONIS AG
+ */
+public interface DdlAlterTable {
+
+ /**
+ * Writes the alter table statements to
@@ -124,4 +156,70 @@ public class DdlWrite {
return dropAll;
}
+ /**
+ * Writes the apply ddl to the target.
+ */
+ public void writeApply(Appendable target) throws IOException {
+ if (!applyDropDependencies.isEmpty()) {
+ target.append("-- drop dependencies\n");
+ target.append(applyDropDependencies.getBuffer());
+ }
+ if (!apply.isEmpty()) {
+ target.append("-- apply changes\n");
+ target.append(apply.getBuffer());
+ }
+ if (!applyAlterTables.isEmpty()) {
+ // target.append("-- apply alter tables\n"); maybe added later. Makes diff easier
+ for (DdlAlterTable alterTable : applyAlterTables.values()) {
+ alterTable.write(target);
+ }
+ }
+ if (!applyPostAlter.isEmpty()) {
+ // target.append("-- apply post alter\n"); maybe added later.
+ target.append(applyPostAlter.getBuffer());
+ }
+ if (!applyForeignKeys.isEmpty()) {
+ // target.append("-- foreign keys and indices\n"); maybe added later.
+ target.append(applyForeignKeys.getBuffer());
+ }
+
+ if (!applyHistoryView.isEmpty()) {
+ target.append(applyHistoryView.getBuffer());
+ }
+
+ if (!applyHistoryTrigger.isEmpty()) {
+ target.append(applyHistoryTrigger.getBuffer());
+ }
+ }
+
+ /**
+ * Writes the drop all ddl to the target.
+ */
+ public void writeDropAll(Appendable target) throws IOException {
+ if (!dropAllForeignKeys.isEmpty()) {
+ target.append("-- drop all foreign keys\n");
+ target.append(dropAllForeignKeys.getBuffer());
+ }
+ if (!dropAll.isEmpty()) {
+ target.append("-- drop all\n");
+ target.append(dropAll.getBuffer());
+ }
+ }
+
+ /**
+ * Returns all create statements. Mainly used for unit-tests
+ */
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ try {
+ writeDropAll(sb);
+ writeApply(sb);
+ } catch (IOException e) {
+ // can not happen
+ }
+ return sb.toString();
+ }
+
+
}
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/AbstractHanaDdl.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/AbstractHanaDdl.java
index d9833753a..b664354b2 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/AbstractHanaDdl.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/AbstractHanaDdl.java
@@ -3,12 +3,21 @@ package io.ebeaninternal.dbmigration.ddlgeneration.platform;
import io.ebean.config.DatabaseConfig;
import io.ebean.config.dbplatform.DatabasePlatform;
import io.ebean.config.dbplatform.DbPlatformType;
+import io.ebeaninternal.dbmigration.ddlgeneration.DdlAlterTable;
import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
import io.ebeaninternal.dbmigration.ddlgeneration.DdlHandler;
import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
import io.ebeaninternal.dbmigration.migration.AlterColumn;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -18,16 +27,13 @@ public abstract class AbstractHanaDdl extends PlatformDdl {
public AbstractHanaDdl(DatabasePlatform platform) {
super(platform);
- this.addColumn = "add (";
- this.addColumnSuffix = ")";
- this.alterColumn = "alter (";
- this.alterColumnSuffix = ")";
- this.columnDropDefault = " default null";
- this.columnSetDefault = " default";
- this.columnSetNotnull = " not null";
+ this.addColumn = "add";
+ this.alterColumn = "alter";
+ this.columnDropDefault = "default null";
+ this.columnSetDefault = "default";
+ this.columnSetNotnull = "not null";
this.columnSetNull = " null";
- this.dropColumn = "drop (";
- this.dropColumnSuffix = ")";
+ this.dropColumn = "drop";
this.dropConstraintIfExists = "drop constraint ";
this.dropIndexIfExists = "drop index ";
this.dropSequenceIfExists = "drop sequence ";
@@ -52,29 +58,21 @@ public abstract class AbstractHanaDdl extends PlatformDdl {
: (alter.getDefaultValue() != null ? alter.getDefaultValue() : alter.getCurrentDefaultValue());
String defaultValueClause = (defaultValue == null || defaultValue.isEmpty()) ? "" : " default " + defaultValue;
- DdlBuffer buffer = writer.apply();
if (!isConvertible(currentType, type)) {
// add an intermediate conversion if possible
if (isNumberType(currentType)) {
// numbers can always be converted to decimal
- buffer.append("alter table ").append(tableName).append(" ").append(alterColumn).append(" ").append(columnName)
- .append(" decimal ").append(notnullClause).append(alterColumnSuffix)
- .endOfStatement();
+ alterTable(writer, tableName).append(alterColumn, columnName).append("decimal").append(notnullClause);
} else if (isStringType(currentType)) {
// strings can always be converted to nclob
// Note: we do not add default clause here to avoid error[SAP DBTech JDBC: [336]: invalid default value:
// default value cannot be created on column of data type NCLOB
- buffer.append("alter table ").append(tableName).append(" ").append(alterColumn).append(" ").append(columnName)
- .append(" nclob").append(notnullClause).append(alterColumnSuffix)
- .endOfStatement();
+ alterTable(writer, tableName).append(alterColumn, columnName).append("nclob").append(notnullClause);
}
}
- buffer.append("alter table ").append(tableName).append(" ").append(alterColumn).append(" ").append(columnName)
- .append(" ").append(type).append(defaultValueClause).append(notnullClause).append(alterColumnSuffix);
-
- buffer.endOfStatement();
+ alterTable(writer, tableName).append(alterColumn, columnName).append(type).append(defaultValueClause).append(notnullClause);
}
@Override
@@ -127,8 +125,7 @@ public abstract class AbstractHanaDdl extends PlatformDdl {
*/
@Override
public void alterTableDropColumn(DdlWrite writer, String tableName, String columnName) {
- writer.apply().append("CALL usp_ebean_drop_column('").append(tableName).append("', '").append(columnName).append("')")
- .endOfStatement();
+ alterTable(writer, tableName).raw("CALL usp_ebean_drop_column('").append(tableName).append("', '").append(columnName).append("')");
}
/**
@@ -202,4 +199,71 @@ public abstract class AbstractHanaDdl extends PlatformDdl {
return type != null
&& (type.startsWith("varchar") || type.startsWith("nvarchar") || "clob".equals(type) || "nclob".equals(type));
}
+
+ @Override
+ protected DdlAlterTable alterTable(DdlWrite writer, String tableName) {
+ return writer.applyAlterTable(tableName, HanaAlterTableWrite::new);
+ }
+
+ /**
+ * Joins alter table commands and add open/closing brackets for the alter statements
+ */
+ private static class HanaAlterTableWrite extends BaseAlterTableWrite {
+
+ public HanaAlterTableWrite(String tableName) {
+ super(tableName);
+ }
+
+ @Override
+ protected Listtarget
+ */
+ void write(Appendable target) throws IOException;
+
+ /**
+ * Adds an alter table command for given column. When you invoke
+ * alterTable(writer, "my_table").add("alter column","my_column).append("type integer") the resulting DDL (in
+ * standard implementation) would be
+ * alter table my_table alter column my_column type integer
+ *
+ * @return a DdlBuffer, which can be used for further appends. Note you MUST NOT call .endOfStatement() on this
+ * buffer.
+ */
+ DdlBuffer append(String operation, String columnName);
+
+ /**
+ * Adds a raw command. This is mainly used for executing user stored procedures.
+ */
+ DdlBuffer raw(String string);
+
+ /**
+ * Flag that detects if history DDL (switching on) is handled for this table.
+ */
+ boolean isHistoryHandled();
+
+ /**
+ * Sets the history handled flag for this table.
+ */
+ void setHistoryHandled();
+
+
+}
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/DdlWrite.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/DdlWrite.java
index eff523d09..a0abf8350 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/DdlWrite.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/DdlWrite.java
@@ -1,5 +1,10 @@
package io.ebeaninternal.dbmigration.ddlgeneration;
+import java.io.IOException;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.function.Function;
+
import io.ebeaninternal.dbmigration.ddlgeneration.platform.BaseDdlBuffer;
import io.ebeaninternal.dbmigration.model.MConfiguration;
import io.ebeaninternal.dbmigration.model.MTable;
@@ -16,6 +21,10 @@ public class DdlWrite {
private final DdlBuffer apply = new BaseDdlBuffer();
+ private final Maptablename.
+ *
+ * Note: All alters on a particular table are sorted in natural order in the ddl script. This allows optimizing the alters by
+ * merging them or doing a reorg table after altering is done.
+ *
+ * @param tableName the table name
+ * @param factory the factory to construct a new object
+ * @return
+ */
+ public DdlAlterTable applyAlterTable(String tableName, Functiontarget.
+ */
+ @Override
+ public void write(Appendable target) throws IOException {
+ for (AlterCmd cmd : postProcessCommands(Collections.unmodifiableList(cmds))) {
+ cmd.write(target);
+ target.append(";\n");
+ }
+ }
+
+ @Override
+ public boolean isHistoryHandled() {
+ return historyHandled;
+ }
+
+ @Override
+ public void setHistoryHandled() {
+ historyHandled = true;
+ }
+}
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 f4b8980c1..aa0241532 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
@@ -11,7 +11,6 @@ import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
import io.ebeaninternal.dbmigration.ddlgeneration.DdlOptions;
import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
import io.ebeaninternal.dbmigration.ddlgeneration.TableDdl;
-import io.ebeaninternal.dbmigration.ddlgeneration.platform.util.IndexSet;
import io.ebeaninternal.dbmigration.migration.AddColumn;
import io.ebeaninternal.dbmigration.migration.AddHistoryTable;
import io.ebeaninternal.dbmigration.migration.AddTableComment;
@@ -127,29 +126,29 @@ public class BaseTableDdl implements TableDdl {
after = getScriptsForPlatform(alter.getAfter());
}
- void writeBefore(DdlBuffer buffer) {
+ void write(DdlWrite writer) {
if (!before.isEmpty()) {
- buffer.end();
- }
-
- if (!before.isEmpty() && withHistory) {
- buffer.append("-- NOTE: table has @History - special migration may be necessary").newLine();
- }
- for (String ddlScript : before) {
- buffer.appendStatement(translate(ddlScript, tableName, columnName, defaultValue));
- }
- }
-
- void writeAfter(DdlBuffer buffer) {
- if (!after.isEmpty() && withHistory) {
- buffer.append("-- NOTE: table has @History - special migration may be necessary").newLine();
- }
- // here we run post migration scripts
- for (String ddlScript : after) {
- buffer.appendStatement(translate(ddlScript, tableName, columnName, defaultValue));
+ writer.apply().end();
+ if (withHistory) {
+ writer.apply().append("-- NOTE: table has @History - special migration may be necessary").newLine();
+ }
+ for (String ddlScript : before) {
+ writer.apply().appendStatement(translate(ddlScript, tableName, columnName, defaultValue));
+ }
}
+ // effective order in DDL.sql:
+ // 'before' goes to apply-buffer
+ // altered columns will be in the alterTable buffers.
+ // 'after' goes to the post-alter-buffer
if (!after.isEmpty()) {
- buffer.end();
+ writer.applyPostAlter().append("-- NOTE: table has @History - special migration may be necessary").newLine();
+
+ // here we run post migration scripts
+ for (String ddlScript : after) {
+ writer.applyPostAlter().appendStatement(translate(ddlScript, tableName, columnName, defaultValue));
+ }
+
+ writer.applyPostAlter().end();
}
}
@@ -248,7 +247,7 @@ public class BaseTableDdl implements TableDdl {
}
}
if (platformDdl.isInlineForeignKeys()) {
- writeInlineForeignKeys(writer, createTable);
+ writeInlineForeignKeys(apply, createTable);
}
apply.newLine().append(")");
addTableStorageEngine(apply, createTable);
@@ -340,7 +339,8 @@ public class BaseTableDdl implements TableDdl {
uqName = col.getUnique();
}
String[] columnNames = {col.getName()};
- writer.apply().appendStatement(platformDdl.alterTableAddUniqueConstraint(tableName, uqName, columnNames, Boolean.TRUE.equals(col.isNotnull()) ? null : columnNames));
+ String[] nullableColumns = Boolean.TRUE.equals(col.isNotnull()) ? null : columnNames;
+ writer.applyPostAlter().appendStatement(platformDdl.alterTableAddUniqueConstraint(tableName, uqName, columnNames, nullableColumns));
writer.dropAllForeignKeys().appendStatement(platformDdl.dropIndex(uqName, tableName));
}
@@ -349,7 +349,7 @@ public class BaseTableDdl implements TableDdl {
String[] columnNames = split(constraint.getColumnNames());
String[] nullableColumns = split(constraint.getNullableColumns());
- writer.apply().appendStatement(platformDdl.alterTableAddUniqueConstraint(tableName, uqName, columnNames, nullableColumns));
+ writer.applyPostAlter().appendStatement(platformDdl.alterTableAddUniqueConstraint(tableName, uqName, columnNames, nullableColumns));
writer.dropAllForeignKeys().appendStatement(platformDdl.dropIndex(uqName, tableName));
}
}
@@ -368,25 +368,25 @@ public class BaseTableDdl implements TableDdl {
platformDdl.createWithHistory(writer, table);
}
- protected void writeInlineForeignKeys(DdlWrite writer, CreateTable createTable) {
+ protected void writeInlineForeignKeys(DdlBuffer buffer, CreateTable createTable) {
for (Column column : createTable.getColumn()) {
String references = column.getReferences();
if (hasValue(references)) {
- writeInlineForeignKey(writer, column);
+ writeInlineForeignKey(buffer, column);
}
}
- writeInlineCompoundForeignKeys(writer, createTable);
+ writeInlineCompoundForeignKeys(buffer, createTable);
}
- protected void writeInlineForeignKey(DdlWrite writer, Column column) {
+ protected void writeInlineForeignKey(DdlBuffer buffer, Column column) {
String fkConstraint = platformDdl.tableInlineForeignKey(new WriteForeignKey(null, column));
- writer.apply().append(",").newLine().append(" ").append(fkConstraint);
+ buffer.append(",").newLine().append(" ").append(fkConstraint);
}
- protected void writeInlineCompoundForeignKeys(DdlWrite writer, CreateTable createTable) {
+ protected void writeInlineCompoundForeignKeys(DdlBuffer buffer, CreateTable createTable) {
for (ForeignKey key : createTable.getForeignKey()) {
String fkConstraint = platformDdl.tableInlineForeignKey(new WriteForeignKey(null, key));
- writer.apply().append(",").newLine().append(" ").append(fkConstraint);
+ buffer.append(",").newLine().append(" ").append(fkConstraint);
}
}
@@ -558,7 +558,7 @@ public class BaseTableDdl implements TableDdl {
@Override
public void generate(DdlWrite writer, CreateIndex index) {
if (platformInclude(index.getPlatforms())) {
- writer.apply().appendStatement(platformDdl.createIndex(new WriteCreateIndex(index)));
+ writer.applyPostAlter().appendStatement(platformDdl.createIndex(new WriteCreateIndex(index)));
writer.dropAll().appendStatement(platformDdl.dropIndex(index.getIndexName(), index.getTableName(), Boolean.TRUE.equals(index.isConcurrent())));
}
}
@@ -566,7 +566,8 @@ public class BaseTableDdl implements TableDdl {
@Override
public void generate(DdlWrite writer, DropIndex dropIndex) {
if (platformInclude(dropIndex.getPlatforms())) {
- writer.apply().appendStatement(platformDdl.dropIndex(dropIndex.getIndexName(), dropIndex.getTableName(), Boolean.TRUE.equals(dropIndex.isConcurrent())));
+ writer.applyDropDependencies()
+ .appendStatement(platformDdl.dropIndex(dropIndex.getIndexName(), dropIndex.getTableName(), Boolean.TRUE.equals(dropIndex.isConcurrent())));
}
}
@@ -574,12 +575,14 @@ public class BaseTableDdl implements TableDdl {
public void generate(DdlWrite writer, AddUniqueConstraint constraint) {
if (platformInclude(constraint.getPlatforms())) {
if (DdlHelp.isDropConstraint(constraint.getColumnNames())) {
- writer.apply().appendStatement(platformDdl.alterTableDropUniqueConstraint(constraint.getTableName(), constraint.getConstraintName()));
+ writer.applyDropDependencies()
+ .appendStatement(platformDdl.alterTableDropUniqueConstraint(constraint.getTableName(), constraint.getConstraintName()));
} else {
String[] cols = split(constraint.getColumnNames());
String[] nullableColumns = split(constraint.getNullableColumns());
- writer.apply().appendStatement(platformDdl.alterTableAddUniqueConstraint(constraint.getTableName(), constraint.getConstraintName(), cols, nullableColumns));
+ writer.applyPostAlter()
+ .appendStatement(platformDdl.alterTableAddUniqueConstraint(constraint.getTableName(), constraint.getConstraintName(), cols, nullableColumns));
}
}
}
@@ -587,9 +590,9 @@ public class BaseTableDdl implements TableDdl {
@Override
public void generate(DdlWrite writer, AlterForeignKey alterForeignKey) {
if (DdlHelp.isDropForeignKey(alterForeignKey.getColumnNames())) {
- writer.apply().appendStatement(platformDdl.alterTableDropForeignKey(alterForeignKey.getTableName(), alterForeignKey.getName()));
+ writer.applyDropDependencies().appendStatement(platformDdl.alterTableDropForeignKey(alterForeignKey.getTableName(), alterForeignKey.getName()));
} else {
- writer.apply().appendStatement(platformDdl.alterTableAddForeignKey(writer.getOptions(), new WriteForeignKey(alterForeignKey)));
+ writer.applyForeignKeys().appendStatement(platformDdl.alterTableAddForeignKey(writer.getOptions(), new WriteForeignKey(alterForeignKey)));
}
}
@@ -634,7 +637,7 @@ public class BaseTableDdl implements TableDdl {
@Override
public void generate(DdlWrite writer, AddTableComment addTableComment) {
if (hasValue(addTableComment.getComment())) {
- platformDdl.addTableComment(writer.apply(), addTableComment.getName(), addTableComment.getComment());
+ platformDdl.addTableComment(writer.applyPostAlter(), addTableComment.getName(), addTableComment.getComment());
}
}
@@ -669,7 +672,7 @@ public class BaseTableDdl implements TableDdl {
*/
@Override
public void generate(DdlWrite writer, DropTable dropTable) {
- dropTable(writer.apply(), dropTable.getName());
+ dropTable(writer.applyPostAlter(), dropTable.getName());
if (hasValue(dropTable.getSequenceCol())
&& platformDdl.getPlatform().getDbIdentity().isSupportsSequence()) {
String sequenceName = dropTable.getSequenceName();
@@ -702,7 +705,7 @@ public class BaseTableDdl implements TableDdl {
@Override
public void generate(DdlWrite writer, AlterColumn alterColumn) {
DdlMigrationHelp ddlHelp = new DdlMigrationHelp(alterColumn);
- ddlHelp.writeBefore(writer.apply());
+ ddlHelp.write(writer);
if (isTrue(alterColumn.isHistoryExclude())) {
regenerateHistoryTriggers(alterColumn.getTableName(), HistoryTableUpdate.Change.EXCLUDE, alterColumn.getColumnName());
@@ -750,11 +753,10 @@ public class BaseTableDdl implements TableDdl {
// add constraint last (after potential type change)
addCheckConstraint(writer, alterColumn);
}
- ddlHelp.writeAfter(writer.apply());
}
private void alterColumnComment(DdlWrite writer, AlterColumn alterColumn) {
- platformDdl.addColumnComment(writer.apply(), alterColumn.getTableName(), alterColumn.getColumnName(), alterColumn.getComment());
+ platformDdl.addColumnComment(writer.applyPostAlter(), alterColumn.getTableName(), alterColumn.getColumnName(), alterColumn.getComment());
}
/**
@@ -792,23 +794,28 @@ public class BaseTableDdl implements TableDdl {
}
protected void dropCheckConstraint(DdlWrite writer, AlterColumn alter, String constraintName) {
- writer.apply().appendStatement(platformDdl.alterTableDropConstraint(alter.getTableName(), constraintName));
+ writer.applyDropDependencies()
+ .appendStatement(platformDdl.alterTableDropConstraint(alter.getTableName(), constraintName));
}
protected void addCheckConstraint(DdlWrite writer, AlterColumn alter) {
- writer.apply().appendStatement(platformDdl.alterTableAddCheckConstraint(alter.getTableName(), alter.getCheckConstraintName(), alter.getCheckConstraint()));
+ writer.applyPostAlter()
+ .appendStatement(platformDdl.alterTableAddCheckConstraint(alter.getTableName(), alter.getCheckConstraintName(), alter.getCheckConstraint()));
}
+
protected void alterColumnAddForeignKey(DdlWrite writer, AlterColumn alterColumn) {
- alterTableAddForeignKey(writer.getOptions(), writer.apply(), new WriteForeignKey(alterColumn));
+ alterTableAddForeignKey(writer.getOptions(), writer.applyForeignKeys(), new WriteForeignKey(alterColumn));
}
protected void alterColumnDropForeignKey(DdlWrite writer, AlterColumn alter) {
- writer.apply().appendStatement(platformDdl.alterTableDropForeignKey(alter.getTableName(), alter.getDropForeignKey()));
+ writer.applyDropDependencies()
+ .appendStatement(platformDdl.alterTableDropForeignKey(alter.getTableName(), alter.getDropForeignKey()));
}
protected void alterColumnDropUniqueConstraint(DdlWrite writer, AlterColumn alter) {
- writer.apply().appendStatement(platformDdl.alterTableDropUniqueConstraint(alter.getTableName(), alter.getDropUnique()));
+ writer.applyDropDependencies()
+ .appendStatement(platformDdl.alterTableDropUniqueConstraint(alter.getTableName(), alter.getDropUnique()));
}
protected void alterColumnAddUniqueOneToOneConstraint(DdlWrite writer, AlterColumn alter) {
@@ -822,7 +829,8 @@ public class BaseTableDdl implements TableDdl {
protected void addUniqueConstraint(DdlWrite writer, AlterColumn alter, String uqName) {
String[] cols = {alter.getColumnName()};
boolean notNull = alter.isNotnull() != null ? alter.isNotnull() : Boolean.TRUE.equals(alter.isNotnull());
- writer.apply().appendStatement(platformDdl.alterTableAddUniqueConstraint(alter.getTableName(), uqName, cols, notNull ? null : cols));
+ writer.applyPostAlter()
+ .appendStatement(platformDdl.alterTableAddUniqueConstraint(alter.getTableName(), uqName, cols, notNull ? null : cols));
writer.dropAllForeignKeys().appendStatement(platformDdl.dropIndex(uqName, alter.getTableName()));
}
@@ -835,18 +843,15 @@ public class BaseTableDdl implements TableDdl {
protected void alterTableAddColumn(DdlWrite writer, String tableName, Column column, boolean onHistoryTable, boolean withHistory) {
DdlMigrationHelp help = new DdlMigrationHelp(tableName, column, withHistory);
if (!onHistoryTable) {
- help.writeBefore(writer.apply());
+ help.write(writer);
}
platformDdl.alterTableAddColumn(writer, tableName, column, onHistoryTable, help.getDefaultValue());
final String comment = column.getComment();
if (comment != null && !comment.isEmpty()) {
- platformDdl.addColumnComment(writer.apply(), tableName, column.getName(), comment);
+ platformDdl.addColumnComment(writer.applyPostAlter(), tableName, column.getName(), comment);
}
- if (!onHistoryTable) {
- help.writeAfter(writer.apply());
- }
}
protected boolean isFalse(Boolean value) {
diff --git a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DbTriggerBasedHistoryDdl.java b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DbTriggerBasedHistoryDdl.java
index 252cd271b..10644a8a1 100644
--- a/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DbTriggerBasedHistoryDdl.java
+++ b/ebean-ddl-generator/src/main/java/io/ebeaninternal/dbmigration/ddlgeneration/platform/DbTriggerBasedHistoryDdl.java
@@ -5,7 +5,6 @@ import io.ebean.config.DbConstraintNaming;
import io.ebeaninternal.dbmigration.ddlgeneration.DdlBuffer;
import io.ebeaninternal.dbmigration.ddlgeneration.DdlWrite;
import io.ebeaninternal.dbmigration.migration.AddHistoryTable;
-import io.ebeaninternal.dbmigration.migration.AlterColumn;
import io.ebeaninternal.dbmigration.migration.DropHistoryTable;
import io.ebeaninternal.dbmigration.model.MColumn;
import io.ebeaninternal.dbmigration.model.MTable;
@@ -63,8 +62,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
protected abstract void updateHistoryTriggers(DbTriggerUpdate triggerUpdate);
/**
- * Process the HistoryTableUpdate which can result in changes to the apply, rollback
- * and drop scripts.
+ * Process the HistoryTableUpdate which can result in changes to the apply, rollback and drop scripts.
*/
protected void updateTriggers(DdlWrite writer, MTable table, HistoryTableUpdate update) {
@@ -88,7 +86,10 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
// drop in appropriate order
dropTriggers(writer.applyDropDependencies(), baseTable);
- dropHistoryTableEtc(writer.applyDropDependencies(), baseTable);
+ dropWithHistoryView(writer.applyDropDependencies(), baseTable);
+ dropHistoryTable(writer.applyDropDependencies(), baseTable);
+
+ dropSysPeriodColumns(writer, baseTable);
}
@Override
@@ -107,14 +108,19 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
public void createWithHistory(DdlWrite writer, MTable table) {
String baseTable = table.getName();
- String whenCreatedColumn = table.getWhenCreatedColumn();
- dropTriggers(writer.dropAll(), baseTable);
- dropHistoryTableEtc(writer.dropAll(), baseTable);
+ addSysPeriodColumns(writer.apply(), baseTable, table.getWhenCreatedColumn());
+ createHistoryTable(writer.applyPostAlter(), table);
- addHistoryTable(writer, table, whenCreatedColumn);
- createStoredFunction(writer, table);
createTriggers(writer, table);
+ createWithHistoryView(writer.applyPostAlter(), table.getName());
+
+ // drop all scripts
+ dropTriggers(writer.dropAll(), baseTable);
+ dropWithHistoryView(writer.dropAll(), baseTable);
+ dropHistoryTable(writer.dropAll(), baseTable);
+ // no need to dropSysPeriodColumns as whole table will be deleted soon
+
}
protected abstract void createTriggers(DdlWrite writer, MTable table);
@@ -156,7 +162,7 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
DdlBuffer apply = writer.applyHistoryView();
addSysPeriodColumns(apply, baseTableName, whenCreatedColumn);
- createHistoryTable(apply, table);
+ createHistoryTable(writer.applyPostAlter(), table);
createWithHistoryView(apply, baseTableName);
}
@@ -234,18 +240,17 @@ public abstract class DbTriggerBasedHistoryDdl implements PlatformHistoryDdl {
appendColumnName(apply, prefix, sysPeriodEnd);
}
- protected void dropHistoryTableEtc(DdlBuffer buffer, String baseTableName) {
-
- buffer.append("drop view ").append(baseTableName).append(viewSuffix).endOfStatement();
- dropSysPeriodColumns(buffer, baseTableName);
- buffer.append("drop table ").append(baseTableName).append(historySuffix).endOfStatement().end();
+ protected void dropWithHistoryView(DdlBuffer apply, String baseTableName) {
+ apply.append("drop view ").append(baseTableName).append(viewSuffix).endOfStatement();
}
- protected void dropSysPeriodColumns(DdlBuffer buffer, String baseTableName) {
- DdlWrite writer = new DdlWrite();
+ protected void dropHistoryTable(DdlBuffer apply, String baseTableName) {
+ apply.append("drop table ").append(baseTableName).append(historySuffix).endOfStatement().end();
+ }
+
+ protected void dropSysPeriodColumns(DdlWrite writer, String baseTableName) {
platformDdl.alterTableDropColumn(writer, baseTableName, sysPeriodStart);
platformDdl.alterTableDropColumn(writer, baseTableName, sysPeriodEnd);
- buffer.append(writer.apply().getBuffer()); // Workaround - will be removed later
}
protected void appendInsertIntoHistory(DdlBuffer buffer, String historyTable, List