#563 - ENH: DDL DB Migration - add a suppressDropsForever="true" attribute such that drops we never want to run are not warned on and can't be selected for a migration.

This commit is contained in:
Robin Bygrave committed 2016-02-12 14:33:19 +13:00
1 parent 4c3d1d9edd
commit 4848c24a0a
7 files changed
+467 -40

No files matched your search

@@ -222,8 +222,9 @@ public class DbMigration {
private void generateDiff(Request request) throws IOException {
if (request.hasPendingDrops()) {
logger.info("Pending un-applied drops in versions {}", request.getPendingDrops());
List<String> pendingDrops = request.getPendingDrops();
if (!pendingDrops.isEmpty()) {
logger.info("Pending un-applied drops in versions {}", pendingDrops);
}
ModelDiff diff = request.createDiff();
@@ -240,8 +241,10 @@ public class DbMigration {
Migration migration = request.migrationForPendingDrop(pendingVersion);
generateMigration(request, migration, pendingVersion);
if (request.hasPendingDrops()) {
logger.info("... remaining pending un-applied drops in versions {}", request.getPendingDrops());
List<String> pendingDrops = request.getPendingDrops();
if (!pendingDrops.isEmpty()) {
logger.info("... remaining pending un-applied drops in versions {}", pendingDrops);
}
}
@@ -267,13 +270,6 @@ public class DbMigration {
this.current = currentModel.read();
}
/**
* Return true if there are pending un-applied drops.
*/
public boolean hasPendingDrops() {
return migrated.hasPendingDrops();
}
/**
* Return the migration for the pending drops for a given version.
*/
@@ -28,6 +28,7 @@ import javax.xml.bind.annotation.XmlType;
* &lt;/sequence>
* &lt;attribute name="type" use="required" type="{http://ebean-orm.github.io/xml/ns/dbmigration}changeSetType" />
* &lt;attribute name="dropsFor" type="{http://www.w3.org/2001/XMLSchema}string" />
* &lt;attribute name="suppressDropsForever" type="{http://www.w3.org/2001/XMLSchema}boolean" />
* &lt;attribute name="generated" type="{http://www.w3.org/2001/XMLSchema}boolean" />
* &lt;attribute name="author" type="{http://www.w3.org/2001/XMLSchema}string" />
* &lt;attribute name="comment" type="{http://www.w3.org/2001/XMLSchema}string" />
@@ -65,6 +66,8 @@ public class ChangeSet {
protected ChangeSetType type;
@XmlAttribute(name = "dropsFor")
protected String dropsFor;
@XmlAttribute(name = "suppressDropsForever")
protected Boolean suppressDropsForever;
@XmlAttribute(name = "generated")
protected Boolean generated;
@XmlAttribute(name = "author")
@@ -161,6 +164,30 @@ public class ChangeSet {
this.dropsFor = value;
}
/**
* Gets the value of the suppressDropsForever property.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public Boolean isSuppressDropsForever() {
return suppressDropsForever;
}
/**
* Sets the value of the suppressDropsForever property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void setSuppressDropsForever(Boolean value) {
this.suppressDropsForever = value;
}
/**
* Gets the value of the generated property.
*
@@ -92,9 +92,9 @@ public class ModelContainer {
if (pending) {
// un-applied drop columns etc
pendingDrops.add(version, changeSet);
} else if (isDropsFor(changeSet)) {
// applied drops (so no longer pending)
pendingDrops.remove(MigrationVersion.parse(changeSet.getDropsFor()));
pendingDrops.appliedDropsFor(MigrationVersion.parse(changeSet.getDropsFor()));
}
if (!isDropsFor(changeSet)) {
applyChangeSet(changeSet);
@@ -265,13 +265,6 @@ public class ModelContainer {
indexes.put(indexName, new MIndex(indexName, tableName, columnNames));
}
/**
* Return true if there are pending drops.
*/
public boolean hasPendingDrops() {
return !pendingDrops.isEmpty();
}
/**
* Return the list of versions containing un-applied pending drops.
*/
@@ -37,23 +37,26 @@ public class PendingDrops {
List<String> versions = new ArrayList<String>();
for (Entry value : map.values()) {
versions.add(value.version.asString());
if (value.hasPendingDrops()) {
versions.add(value.version.asString());
}
}
return versions;
}
/**
* Remove the pending drops for a version (as they have been applied).
* All the pending drops for this migration version have been applied so we need
* to remove the (unsuppressed) pending drops for this version.
*/
public void remove(MigrationVersion version) {
map.remove(version.normalised());
}
public boolean appliedDropsFor(MigrationVersion version) {
Entry entry = map.get(version.normalised());
if (entry.removeDrops()) {
// it had no suppressForever changeSets so remove completely
map.remove(version.normalised());
return true;
}
/**
* Return true if there are no pending drops.
*/
public boolean isEmpty() {
return map.isEmpty();
return false;
}
/**
@@ -64,34 +67,43 @@ public class PendingDrops {
*/
public Migration migrationForVersion(String pendingVersion) {
Entry entry = getChangeSets(pendingVersion);
Entry entry = getEntry(pendingVersion);
Migration migration = new Migration();
for (ChangeSet changeSet : entry.list) {
changeSet.setType(ChangeSetType.APPLY);
changeSet.setDropsFor(entry.version.asString());
migration.getChangeSet().add(changeSet);
if (!isSuppressForever(changeSet)) {
changeSet.setType(ChangeSetType.APPLY);
changeSet.setDropsFor(entry.version.asString());
migration.getChangeSet().add(changeSet);
}
}
if (migration.getChangeSet().isEmpty()) {
throw new IllegalArgumentException("The remaining pendingDrops changeSets in migration ["+pendingVersion+"] are suppressDropsForever=true and can't be applied");
}
if (!entry.containsSuppressForever()) {
// we can remove it completely as it has no suppressForever changes
map.remove(entry.version.normalised());
}
return migration;
}
private Entry getChangeSets(String pendingVersion) {
private Entry getEntry(String pendingVersion) {
if ("next".equalsIgnoreCase(pendingVersion)) {
Iterator<Entry> it = map.values().iterator();
if (it.hasNext()) {
Entry first = it.next();
it.remove();
return first;
return it.next();
}
} else {
Entry remove = map.remove(MigrationVersion.parse(pendingVersion).normalised());
Entry remove = map.get(MigrationVersion.parse(pendingVersion).normalised());
if (remove != null) {
return remove;
}
}
throw new IllegalArgumentException("No pending changeSets for version [" + pendingVersion + "] found");
throw new IllegalArgumentException("No 'pendingDrops' changeSets for migration version [" + pendingVersion + "] found");
}
/**
@@ -113,6 +125,14 @@ public class PendingDrops {
}
}
/**
* Return true if there is an Entry for the given version.
*/
boolean testContainsEntryFor(MigrationVersion version) {
return map.containsKey(version.normalised());
}
static class Entry {
final MigrationVersion version;
@@ -126,6 +146,51 @@ public class PendingDrops {
void add(ChangeSet changeSet) {
list.add(changeSet);
}
/**
* Return true if this contains suppressForever changeSets.
*/
boolean containsSuppressForever() {
for (ChangeSet changeSet : list) {
if (isSuppressForever(changeSet)) {
return true;
}
}
return false;
}
/**
* Return true if this contains drops that can be applied / migrated.
*/
boolean hasPendingDrops() {
for (ChangeSet changeSet : list) {
if (!isSuppressForever(changeSet)) {
return true;
}
}
return false;
}
/**
* Remove the drops that are not suppressForever and return true if that
* removed all the changeSets (and there are no suppressForever ones).
*/
boolean removeDrops() {
Iterator<ChangeSet> iterator = list.iterator();
while (iterator.hasNext()) {
ChangeSet next = iterator.next();
if (!isSuppressForever(next)) {
iterator.remove();
}
}
return list.isEmpty();
}
}
private static boolean isSuppressForever(ChangeSet next) {
return Boolean.TRUE.equals(next.isSuppressDropsForever());
}
}