Java tutorial
package org.jumpmind.db.platform; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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. */ import java.sql.Types; import java.text.DateFormat; import java.text.NumberFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Set; import org.apache.commons.collections.Closure; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.Predicate; import org.apache.commons.lang.StringUtils; import org.jumpmind.db.alter.AddColumnChange; import org.jumpmind.db.alter.AddForeignKeyChange; import org.jumpmind.db.alter.AddIndexChange; import org.jumpmind.db.alter.AddPrimaryKeyChange; import org.jumpmind.db.alter.AddTableChange; import org.jumpmind.db.alter.ColumnAutoIncrementChange; import org.jumpmind.db.alter.ColumnDataTypeChange; import org.jumpmind.db.alter.ColumnDefaultValueChange; import org.jumpmind.db.alter.ColumnRequiredChange; import org.jumpmind.db.alter.ColumnSizeChange; import org.jumpmind.db.alter.CopyColumnValueChange; import org.jumpmind.db.alter.IModelChange; import org.jumpmind.db.alter.ModelComparator; import org.jumpmind.db.alter.PrimaryKeyChange; import org.jumpmind.db.alter.RemoveColumnChange; import org.jumpmind.db.alter.RemoveForeignKeyChange; import org.jumpmind.db.alter.RemoveIndexChange; import org.jumpmind.db.alter.RemovePrimaryKeyChange; import org.jumpmind.db.alter.RemoveTableChange; import org.jumpmind.db.alter.TableChange; import org.jumpmind.db.model.Column; import org.jumpmind.db.model.Database; import org.jumpmind.db.model.ForeignKey; import org.jumpmind.db.model.IIndex; import org.jumpmind.db.model.IndexColumn; import org.jumpmind.db.model.ModelException; import org.jumpmind.db.model.PlatformColumn; import org.jumpmind.db.model.Reference; import org.jumpmind.db.model.Table; import org.jumpmind.db.model.TypeMap; import org.jumpmind.db.util.CallbackClosure; import org.jumpmind.db.util.MultiInstanceofPredicate; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * This class is a collection of Strategy methods for creating the DDL required * to create and drop databases and tables. * * It is hoped that just a single implementation of this class, for each * database should make creating DDL for each physical database fairly * straightforward. * * An implementation of this class can always delegate down to some templating * technology such as Velocity if it requires. Though often that can be quite * complex when attempting to reuse code across many databases. Hopefully only a * small amount code needs to be changed on a per database basis. */ public abstract class AbstractDdlBuilder implements IDdlBuilder { /** The line separator for in between sql commands. */ private static final String LINE_SEPARATOR = System.getProperty("line.separator", "\n"); /** The placeholder for the size value in the native type spec. */ protected static final String SIZE_PLACEHOLDER = "{0}"; /** The Log to which logging calls will be made. */ protected final Logger log = LoggerFactory.getLogger(getClass()); /** The indentation used to indent commands. */ private String indent = " "; /** An optional locale specification for number and date formatting. */ private String valueLocale; /** The date formatter. */ private DateFormat valueDateFormat; /** The date time formatter. */ private DateFormat valueTimeFormat; /** The number formatter. */ private NumberFormat valueNumberFormat; /** Helper object for dealing with default values. */ private DefaultValueHelper defaultValueHelper = new DefaultValueHelper(); /** The character sequences that need escaping. */ private Map<String, String> charSequencesToEscape = new LinkedHashMap<String, String>(); protected DatabaseInfo databaseInfo = new DatabaseInfo(); protected boolean delimitedIdentifierModeOn = true; protected boolean sqlCommentsOn = false; protected boolean scriptModeOn = false; protected String databaseName; /** * Creates a new sql builder. */ public AbstractDdlBuilder(String databaseName) { this.databaseName = databaseName; addEscapedCharSequence("'", "''"); } /** * Returns the default value helper. * * @return The default value helper */ public DefaultValueHelper getDefaultValueHelper() { return defaultValueHelper; } /** * Returns the string used to indent the SQL. * * @return The indentation string */ public String getIndent() { return indent; } /** * Sets the string used to indent the SQL. * * @param indent * The indentation string */ public void setIndent(String indent) { this.indent = indent; } /** * Returns the locale that is used for number and date formatting (when * printing default values and in generates insert/update/delete * statements). * * @return The locale or <code>null</code> if default formatting is used */ public String getValueLocale() { return valueLocale; } /** * Sets the locale that is used for number and date formatting (when * printing default values and in generates insert/update/delete * statements). * * @param localeStr * The new locale or <code>null</code> if default formatting * should be used; Format is "language[_country[_variant]]" */ public void setValueLocale(String localeStr) { if (localeStr != null) { int sepPos = localeStr.indexOf('_'); String language = null; String country = null; String variant = null; if (sepPos > 0) { language = localeStr.substring(0, sepPos); country = localeStr.substring(sepPos + 1); sepPos = country.indexOf('_'); if (sepPos > 0) { variant = country.substring(sepPos + 1); country = country.substring(0, sepPos); } } else { language = localeStr; } if (language != null) { Locale locale = null; if (variant != null) { locale = new Locale(language, country, variant); } else if (country != null) { locale = new Locale(language, country); } else { locale = new Locale(language); } valueLocale = localeStr; setValueDateFormat(DateFormat.getDateInstance(DateFormat.SHORT, locale)); setValueTimeFormat(DateFormat.getTimeInstance(DateFormat.SHORT, locale)); setValueNumberFormat(NumberFormat.getNumberInstance(locale)); return; } } valueLocale = null; setValueDateFormat(null); setValueTimeFormat(null); setValueNumberFormat(null); } /** * Returns the format object for formatting dates in the specified locale. * * @return The date format object or null if no locale is set */ protected DateFormat getValueDateFormat() { return valueDateFormat; } /** * Sets the format object for formatting dates in the specified locale. * * @param format * The date format object */ protected void setValueDateFormat(DateFormat format) { this.valueDateFormat = format; } /** * Returns the format object for formatting times in the specified locale. * * @return The time format object or null if no locale is set */ protected DateFormat getValueTimeFormat() { return valueTimeFormat; } /** * Sets the date format object for formatting times in the specified locale. * * @param format * The time format object */ protected void setValueTimeFormat(DateFormat format) { this.valueTimeFormat = format; } /** * Returns the format object for formatting numbers in the specified locale. * * @return The number format object or null if no locale is set */ protected NumberFormat getValueNumberFormat() { return valueNumberFormat; } /** * Returns a new date format object for formatting numbers in the specified * locale. Platforms can override this if necessary. * * @param format * The number format object */ protected void setValueNumberFormat(NumberFormat format) { this.valueNumberFormat = format; } /** * Adds a char sequence that needs escaping, and its escaped version. * * @param charSequence * The char sequence * @param escapedVersion * The escaped version */ protected void addEscapedCharSequence(String charSequence, String escapedVersion) { charSequencesToEscape.put(charSequence, escapedVersion); } public String createTables(Database database, boolean dropTables) { StringBuilder ddl = new StringBuilder(); createTables(database, dropTables, ddl); return ddl.toString(); } /** * Outputs the DDL required to drop (if requested) and (re)create all tables * in the database model. */ public void createTables(Database database, boolean dropTables, StringBuilder ddl) { if (dropTables) { dropTables(database, ddl); } for (int idx = 0; idx < database.getTableCount(); idx++) { Table table = database.getTable(idx); writeTableComment(table, ddl); createTable(table, ddl, false, false); } // we're writing the external foreignkeys last to ensure that all // referenced tables are already defined createExternalForeignKeys(database, ddl); } public String alterDatabase(Database currentModel, Database desiredModel, IAlterDatabaseInterceptor... alterDatabaseInterceptors) { StringBuilder ddl = new StringBuilder(); alterDatabase(currentModel, desiredModel, ddl, alterDatabaseInterceptors); return ddl.toString(); } public String alterTable(Table currentTable, Table desiredTable, IAlterDatabaseInterceptor... alterDatabaseInterceptors) { Database currentModel = new Database(); currentModel.addTable(currentTable); Database desiredModel = new Database(); desiredModel.addTable(desiredTable); return alterDatabase(currentModel, desiredModel, alterDatabaseInterceptors); } /** * When the platform columns were added alters were not taken into * consideration. Therefore, we copy the desiredPlatformColumn to the * current platform column because the alter code ends up using the current * column to come up with the alter statements. This is a hack that depends * on the fact that none of the alter decision are based upon the current * column's platform column. */ protected void mergeOrRemovePlatformTypes(Database currentModel, Database desiredModel) { Table[] currentTables = currentModel.getTables(); for (Table currentTable : currentTables) { /* * Warning - we don't currently support altering tables across * different catalogs and schemas, so we only need to look up by * name */ Table desiredTable = desiredModel.findTable(currentTable.getName(), false); if (desiredTable != null) { Column[] currentColumns = currentTable.getColumns(); for (Column currentColumn : currentColumns) { Column desiredColumn = desiredTable.getColumnWithName(currentColumn.getName()); if (desiredColumn != null) { currentColumn.removePlatformColumn(databaseName); PlatformColumn desiredPlatformColumn = desiredColumn.findPlatformColumn(databaseName); if (desiredPlatformColumn != null) { currentColumn.addPlatformColumn(desiredPlatformColumn); } } } } } } /** * Generates the DDL to modify an existing database so the schema matches * the specified database schema by using drops, modifications and * additions. Database-specific implementations can change aspect of this * algorithm by redefining the individual methods that compromise it. */ public void alterDatabase(Database currentModel, Database desiredModel, StringBuilder ddl, IAlterDatabaseInterceptor... alterDatabaseInterceptors) { currentModel = currentModel.copy(); mergeOrRemovePlatformTypes(currentModel, desiredModel); ModelComparator comparator = new ModelComparator(databaseName, databaseInfo, delimitedIdentifierModeOn); List<IModelChange> detectedChanges = comparator.compare(currentModel, desiredModel); if (alterDatabaseInterceptors != null) { for (IAlterDatabaseInterceptor interceptor : alterDatabaseInterceptors) { detectedChanges = interceptor.intercept(detectedChanges, currentModel, desiredModel); } } processChanges(currentModel, desiredModel, detectedChanges, ddl); } public boolean isAlterDatabase(Database currentModel, Database desiredModel, IAlterDatabaseInterceptor... alterDatabaseInterceptors) { ModelComparator comparator = new ModelComparator(databaseName, databaseInfo, delimitedIdentifierModeOn); List<IModelChange> detectedChanges = comparator.compare(currentModel, desiredModel); if (alterDatabaseInterceptors != null) { for (IAlterDatabaseInterceptor interceptor : alterDatabaseInterceptors) { detectedChanges = interceptor.intercept(detectedChanges, currentModel, desiredModel); } } return detectedChanges.size() > 0; } /** * Calls the given closure for all changes that are of one of the given * types, and then removes them from the changes collection. * * @param changes * The changes * @param changeTypes * The types to search for * @param closure * The closure to invoke */ protected void applyForSelectedChanges(Collection<IModelChange> changes, Class<?>[] changeTypes, final Closure closure) { final Predicate predicate = new MultiInstanceofPredicate(changeTypes); // basically we filter the changes for all objects where the above // predicate returns true, and for these filtered objects we invoke the // given closure CollectionUtils.filter(changes, new Predicate() { public boolean evaluate(Object obj) { if (predicate.evaluate(obj)) { closure.execute(obj); return false; } else { return true; } } }); } /** * Processes the changes. The default argument performs several passes: * <ol> * <li> * {@link org.jumpmind.db.alter.RemoveForeignKeyChange} and * {@link org.jumpmind.db.alter.RemoveIndexChange} come first to allow for * e.g. subsequent primary key changes or column removal.</li> * <li>{@link org.jumpmind.db.alter.RemoveTableChange} comes after the * removal of foreign keys and indices.</li> * <li>These are all handled together:<br/> * {@link org.jumpmind.db.alter.RemovePrimaryKeyChange}<br/> * {@link org.jumpmind.db.alter.AddPrimaryKeyChange}<br/> * {@link org.jumpmind.db.alter.PrimaryKeyChange}<br/> * {@link org.jumpmind.db.alter.RemoveColumnChange}<br/> * {@link org.jumpmind.db.alter.AddColumnChange}<br/> * {@link org.jumpmind.db.alter.ColumnAutoIncrementChange} <br/> * {@link org.jumpmind.db.alter.ColumnDefaultValueChange} <br/> * {@link org.jumpmind.db.alter.ColumnRequiredChange}<br/> * {@link org.jumpmind.db.alter.ColumnDataTypeChange}<br/> * {@link org.jumpmind.db.alter.ColumnSizeChange}<br/> * The reason for this is that the default algorithm rebuilds the table for * these changes and thus their order is irrelevant.</li> * <li>{@link org.jumpmind.db.alter.AddTableChange}<br/> * needs to come after the table removal (so that tables of the same name * are removed) and before the addition of foreign keys etc.</li> * <li>{@link org.jumpmind.db.alter.AddForeignKeyChange} and * {@link org.jumpmind.db.alter.AddIndexChange} come last after * table/column/primary key additions or changes.</li> * </ol> */ @SuppressWarnings("unchecked") protected void processChanges(Database currentModel, Database desiredModel, List<IModelChange> changes, StringBuilder ddl) { CallbackClosure callbackClosure = new CallbackClosure(this, "processChange", new Class[] { Database.class, Database.class, null, StringBuilder.class }, new Object[] { currentModel, desiredModel, null, ddl }); // 1st pass: removing external constraints and indices applyForSelectedChanges(changes, new Class[] { RemoveForeignKeyChange.class, RemoveIndexChange.class }, callbackClosure); // 2nd pass: removing tables applyForSelectedChanges(changes, new Class[] { RemoveTableChange.class }, callbackClosure); // 3rd pass: changing the structure of tables Predicate predicate = new MultiInstanceofPredicate(new Class[] { RemovePrimaryKeyChange.class, AddPrimaryKeyChange.class, PrimaryKeyChange.class, RemoveColumnChange.class, AddColumnChange.class, ColumnAutoIncrementChange.class, ColumnDefaultValueChange.class, ColumnRequiredChange.class, ColumnDataTypeChange.class, ColumnSizeChange.class, CopyColumnValueChange.class }); processTableStructureChanges(currentModel, desiredModel, CollectionUtils.select(changes, predicate), ddl); // 4th pass: adding tables applyForSelectedChanges(changes, new Class[] { AddTableChange.class }, callbackClosure); // 5th pass: adding external constraints and indices applyForSelectedChanges(changes, new Class[] { AddForeignKeyChange.class, AddIndexChange.class }, callbackClosure); } /** * This is a fall-through callback which generates a warning because a * specific change type wasn't handled. */ protected void processChange(Database currentModel, Database desiredModel, IModelChange change, StringBuilder ddl) { log.warn("Change of type " + change.getClass() + " was not handled"); } /** * Processes the change representing the removal of a foreign key. */ protected void processChange(Database currentModel, Database desiredModel, RemoveForeignKeyChange change, StringBuilder ddl) { writeExternalForeignKeyDropStmt(change.getChangedTable(), change.getForeignKey(), ddl); change.apply(currentModel, delimitedIdentifierModeOn); } /** * Processes the change representing the removal of an index. * * @param currentModel * The current database schema * @param desiredModel * The desired database schema * @param change * The change object */ protected void processChange(Database currentModel, Database desiredModel, RemoveIndexChange change, StringBuilder ddl) { writeExternalIndexDropStmt(change.getChangedTable(), change.getIndex(), ddl); change.apply(currentModel, delimitedIdentifierModeOn); } /** * Processes the change representing the removal of a table. * * @param currentModel * The current database schema * @param desiredModel * The desired database schema * @param change * The change object */ protected void processChange(Database currentModel, Database desiredModel, RemoveTableChange change, StringBuilder ddl) { dropTable(change.getChangedTable(), ddl, false, false); change.apply(currentModel, delimitedIdentifierModeOn); } /** * Processes the change representing the addition of a table. * * @param currentModel * The current database schema * @param desiredModel * The desired database schema * @param change * The change object */ protected void processChange(Database currentModel, Database desiredModel, AddTableChange change, StringBuilder ddl) { createTable(change.getNewTable(), ddl, false, false); change.apply(currentModel, delimitedIdentifierModeOn); } /** * Processes the change representing the addition of a foreign key. * * @param currentModel * The current database schema * @param desiredModel * The desired database schema * @param change * The change object */ protected void processChange(Database currentModel, Database desiredModel, AddForeignKeyChange change, StringBuilder ddl) { writeExternalForeignKeyCreateStmt(desiredModel, change.getChangedTable(), change.getNewForeignKey(), ddl); change.apply(currentModel, delimitedIdentifierModeOn); } /** * Processes the change representing the addition of an index. * * @param currentModel * The current database schema * @param desiredModel * The desired database schema * @param change * The change object */ protected void processChange(Database currentModel, Database desiredModel, AddIndexChange change, StringBuilder ddl) { writeExternalIndexCreateStmt(change.getChangedTable(), change.getNewIndex(), ddl); change.apply(currentModel, delimitedIdentifierModeOn); } protected void filterChanges(Collection<TableChange> changes) { } /** * Processes the changes to the structure of tables. * * @param currentModel * The current database schema * @param desiredModel * The desired database schema * @param changes * The change objects */ protected void processTableStructureChanges(Database currentModel, Database desiredModel, Collection<TableChange> changes, StringBuilder ddl) { filterChanges(changes); LinkedHashMap<String, List<TableChange>> changesPerTable = new LinkedHashMap<String, List<TableChange>>(); LinkedHashMap<String, List<ForeignKey>> unchangedFKs = new LinkedHashMap<String, List<ForeignKey>>(); boolean caseSensitive = delimitedIdentifierModeOn; // we first sort the changes for the tables // however since the changes might contain source or target tables // we use the names rather than the table objects for (Iterator<TableChange> changeIt = changes.iterator(); changeIt.hasNext();) { TableChange change = changeIt.next(); String name = change.getChangedTable().getName(); if (!caseSensitive) { name = name.toUpperCase(); } List<TableChange> changesForTable = (List<TableChange>) changesPerTable.get(name); if (changesForTable == null) { changesForTable = new ArrayList<TableChange>(); changesPerTable.put(name, changesForTable); unchangedFKs.put(name, getUnchangedForeignKeys(currentModel, desiredModel, name)); } changesForTable.add(change); } // we also need to drop the foreign keys of the unchanged tables // referencing the changed tables addRelevantFKsFromUnchangedTables(currentModel, desiredModel, changesPerTable.keySet(), unchangedFKs); // we're dropping the unchanged foreign keys for (Iterator<Map.Entry<String, List<ForeignKey>>> tableFKIt = unchangedFKs.entrySet().iterator(); tableFKIt .hasNext();) { Map.Entry<String, List<ForeignKey>> entry = tableFKIt.next(); Table targetTable = desiredModel.findTable((String) entry.getKey(), caseSensitive); for (Iterator<ForeignKey> fkIt = entry.getValue().iterator(); fkIt.hasNext();) { writeExternalForeignKeyDropStmt(targetTable, fkIt.next(), ddl); } } // We're using a copy of the current model so that the table structure // changes can modify it Database copyOfCurrentModel = copy(currentModel); for (Iterator<Map.Entry<String, List<TableChange>>> tableChangeIt = changesPerTable.entrySet() .iterator(); tableChangeIt.hasNext();) { Map.Entry<String, List<TableChange>> entry = tableChangeIt.next(); processTableStructureChanges(copyOfCurrentModel, desiredModel, entry.getKey(), entry.getValue(), ddl); } // and finally we're re-creating the unchanged foreign keys for (Iterator<Map.Entry<String, List<ForeignKey>>> tableFKIt = unchangedFKs.entrySet().iterator(); tableFKIt .hasNext();) { Map.Entry<String, List<ForeignKey>> entry = tableFKIt.next(); Table targetTable = desiredModel.findTable((String) entry.getKey(), caseSensitive); for (Iterator<ForeignKey> fkIt = entry.getValue().iterator(); fkIt.hasNext();) { writeExternalForeignKeyCreateStmt(desiredModel, targetTable, fkIt.next(), ddl); } } } /** * Determines the unchanged foreign keys of the indicated table. * * @param currentModel * The current model * @param desiredModel * The desired model * @param tableName * The name of the table * @return The list of unchanged foreign keys */ private List<ForeignKey> getUnchangedForeignKeys(Database currentModel, Database desiredModel, String tableName) { ArrayList<ForeignKey> unchangedFKs = new ArrayList<ForeignKey>(); boolean caseSensitive = delimitedIdentifierModeOn; Table sourceTable = currentModel.findTable(tableName, caseSensitive); Table targetTable = desiredModel.findTable(tableName, caseSensitive); for (int idx = 0; idx < targetTable.getForeignKeyCount(); idx++) { ForeignKey targetFK = targetTable.getForeignKey(idx); ForeignKey sourceFK = sourceTable.findForeignKey(targetFK, caseSensitive); if (sourceFK != null) { unchangedFKs.add(targetFK); } } return unchangedFKs; } /** * Adds the foreign keys of the unchanged tables that reference changed * tables to the given map. * * @param currentModel * The current model * @param desiredModel * The desired model * @param namesOfKnownChangedTables * The known names of changed tables * @param fksPerTable * The map table name -> foreign keys to which found foreign keys * will be added to */ private void addRelevantFKsFromUnchangedTables(Database currentModel, Database desiredModel, Set<String> namesOfKnownChangedTables, Map<String, List<ForeignKey>> fksPerTable) { boolean caseSensitive = delimitedIdentifierModeOn; for (int tableIdx = 0; tableIdx < desiredModel.getTableCount(); tableIdx++) { Table targetTable = desiredModel.getTable(tableIdx); String name = targetTable.getName(); Table sourceTable = currentModel.findTable(name, caseSensitive); List<ForeignKey> relevantFks = null; if (!caseSensitive) { name = name.toUpperCase(); } if ((sourceTable != null) && !namesOfKnownChangedTables.contains(name)) { for (int fkIdx = 0; fkIdx < targetTable.getForeignKeyCount(); fkIdx++) { ForeignKey targetFk = targetTable.getForeignKey(fkIdx); ForeignKey sourceFk = sourceTable.findForeignKey(targetFk, caseSensitive); String refName = targetFk.getForeignTableName(); if (!caseSensitive) { refName = refName.toUpperCase(); } if ((sourceFk != null) && namesOfKnownChangedTables.contains(refName)) { if (relevantFks == null) { relevantFks = new ArrayList<ForeignKey>(); fksPerTable.put(name, relevantFks); } relevantFks.add(targetFk); } } } } } /** * Processes the changes to the structure of a single table. * Database-specific implementations might redefine this method, but it is * usually sufficient to redefine the * {@link #processTableStructureChanges(Database, Database, Table, Table, Map, List)} * method instead. */ protected void processTableStructureChanges(Database currentModel, Database desiredModel, String tableName, List<TableChange> changes, StringBuilder ddl) { StringBuilder tableDdl = new StringBuilder(); Database originalModel = copy(currentModel); Table sourceTable = originalModel.findTable(tableName, delimitedIdentifierModeOn); Table targetTable = desiredModel.findTable(tableName, delimitedIdentifierModeOn); // we're enforcing a full rebuild in case of the addition of a required // column without a default value that is not autoincrement boolean requiresFullRebuild = false; for (Iterator<TableChange> changeIt = changes.iterator(); !requiresFullRebuild && changeIt.hasNext();) { TableChange change = changeIt.next(); if (change instanceof AddColumnChange) { AddColumnChange addColumnChange = (AddColumnChange) change; if (addColumnChange.getNewColumn().isRequired() && (addColumnChange.getNewColumn().getDefaultValue() == null) && !addColumnChange.getNewColumn().isAutoIncrement()) { requiresFullRebuild = true; } } } if (!requiresFullRebuild) { processTableStructureChanges(currentModel, desiredModel, sourceTable, targetTable, changes, tableDdl); } if (!changes.isEmpty()) { // we can only copy the data if no required columns without default // value and non-autoincrement have been added boolean canMigrateData = true; for (Iterator<TableChange> it = changes.iterator(); canMigrateData && it.hasNext();) { TableChange change = it.next(); if (change instanceof AddColumnChange) { AddColumnChange addColumnChange = (AddColumnChange) change; if (addColumnChange.getNewColumn().isRequired() && !addColumnChange.getNewColumn().isAutoIncrement() && (addColumnChange.getNewColumn().getDefaultValue() == null)) { log.warn("Data cannot be retained in table " + change.getChangedTable().getName() + " because of the addition of the required column " + addColumnChange.getNewColumn().getName()); canMigrateData = false; } } } Table realTargetTable = getRealTargetTableFor(desiredModel, sourceTable, targetTable); if (canMigrateData) { Table tempTable = getTemporaryTableFor(sourceTable); dropTemporaryTable(tempTable, ddl); createTemporaryTable(tempTable, ddl); writeCopyDataStatement(sourceTable, tempTable, ddl); /* * Note that we don't drop the indices here because the DROP * TABLE will take care of that Likewise, foreign keys have * already been dropped as necessary */ dropTable(sourceTable, ddl, false, true); createTable(realTargetTable, ddl, false, true); writeCopyDataStatement(tempTable, targetTable, ddl); dropTemporaryTable(tempTable, ddl); writeFixLastIdentityValues(targetTable, ddl); } else { dropTable(sourceTable, ddl, false, false); createTable(realTargetTable, ddl, false, false); } } else { ddl.append(tableDdl); } } protected Database copy(Database currentModel) { try { return (Database) currentModel.clone(); } catch (CloneNotSupportedException ex) { throw new DdlException(ex); } } /** * Allows database-specific implementations to handle changes in a database * specific manner. Any handled change should be applied to the given * current model (which is a copy of the real original model) and be removed * from the list of changes.<br/> * In the default implementation, all {@link AddPrimaryKeyChange} changes * are applied via an <code>ALTER TABLE ADD CONSTRAINT</code> statement. * * @param currentModel * The current database schema * @param desiredModel * The desired database schema * @param sourceTable * The original table * @param targetTable * The desired table * @param changes * The change objects for the target table */ protected void processTableStructureChanges(Database currentModel, Database desiredModel, Table sourceTable, Table targetTable, List<TableChange> changes, StringBuilder ddl) { if (changes.size() == 1) { TableChange change = changes.get(0); if (change instanceof AddPrimaryKeyChange) { processChange(currentModel, desiredModel, (AddPrimaryKeyChange) change, ddl); changes.clear(); } } Iterator<TableChange> it = changes.iterator(); while (it.hasNext()) { TableChange change = (TableChange) it.next(); // Check to see if we can generate alters for type changes if (change instanceof ColumnDataTypeChange) { ColumnDataTypeChange typeChange = (ColumnDataTypeChange) change; if (typeChange.getNewTypeCode() == Types.BIGINT) { if (writeAlterColumnDataTypeToBigInt(typeChange, ddl)) { it.remove(); } } } } } protected void processChange(Database currentModel, Database desiredModel, CopyColumnValueChange change, StringBuilder ddl) { ddl.append("UPDATE "); ddl.append(getFullyQualifiedTableNameShorten(change.getChangedTable())); ddl.append(" SET "); printIdentifier(getColumnName(change.getTargetColumn()), ddl); ddl.append("="); printIdentifier(getColumnName(change.getSourceColumn()), ddl); printEndOfStatement(ddl); change.apply(currentModel, delimitedIdentifierModeOn); } protected boolean writeAlterColumnDataTypeToBigInt(ColumnDataTypeChange change, StringBuilder ddl) { return false; } /** * The fully qualified table name shorten */ protected String getFullyQualifiedTableNameShorten(Table table) { String result = ""; if (StringUtils.isNotBlank(table.getCatalog())) { result += getDelimitedIdentifier(table.getCatalog()).concat(databaseInfo.getCatalogSeparator()); } if (StringUtils.isNotBlank(table.getSchema())) { result += getDelimitedIdentifier(table.getSchema()).concat(databaseInfo.getSchemaSeparator()); } result += getDelimitedIdentifier(getTableName(table.getName())); return result; } /** * Creates a temporary table object that corresponds to the given table. * Database-specific implementations may redefine this method if e.g. the * database directly supports temporary tables. The default implementation * simply appends an underscore to the table name and uses that as the table * name. * @param targetTable * The target table * * @return The temporary table */ protected Table getTemporaryTableFor(Table targetTable) { return getTemporaryTableFor(targetTable, "_"); } public Table getBackupTableFor(Table sourceTable) { return getTemporaryTableFor(sourceTable, "x"); } public Table createBackupTableFor(Database model, Table sourceTable, StringBuilder ddl) { Table backupTable = getBackupTableFor(sourceTable); writeTableCreationStmt(backupTable, ddl); printEndOfStatement(ddl); writeCopyDataStatement(sourceTable, backupTable, ddl); return backupTable; } public void restoreTableFromBackup(Table backupTable, Table targetTable, LinkedHashMap<Column, Column> columnMap, StringBuilder ddl) { ddl.append("DELETE FROM "); ddl.append(getFullyQualifiedTableNameShorten(targetTable)); printEndOfStatement(ddl); writeCopyDataStatement(backupTable, targetTable, columnMap, ddl); } protected Table getTemporaryTableFor(Table targetTable, String suffix) { Table table = new Table(); table.setCatalog(targetTable.getCatalog()); table.setSchema(targetTable.getSchema()); table.setName(targetTable.getName() + suffix); table.setType(targetTable.getType()); for (int idx = 0; idx < targetTable.getColumnCount(); idx++) { try { table.addColumn((Column) targetTable.getColumn(idx).clone()); } catch (CloneNotSupportedException ex) { throw new DdlException(ex); } } return table; } /** * Outputs the DDL to create the given temporary table. Per default this is * simply a call to {@link #createTable(Table, Map)}. * @param table * The table */ protected void createTemporaryTable(Table table, StringBuilder ddl) { createTable(table, ddl, true, false); } /** * Outputs the DDL to drop the given temporary table. Per default this is * simply a call to {@link #dropTable(Table)}. * @param table * The table */ protected void dropTemporaryTable(Table table, StringBuilder ddl) { dropTable(table, ddl, true, false); } /** * Creates the target table object that differs from the given target table * only in the indices. More specifically, only those indices are used that * have not changed. * * @param targetModel * The target database * @param sourceTable * The source table * @param targetTable * The target table * @return The table */ protected Table getRealTargetTableFor(Database targetModel, Table sourceTable, Table targetTable) { Table table = new Table(); table.setCatalog(targetTable.getCatalog()); table.setSchema(targetTable.getSchema()); table.setName(targetTable.getName()); table.setType(targetTable.getType()); for (int idx = 0; idx < targetTable.getColumnCount(); idx++) { try { table.addColumn((Column) targetTable.getColumn(idx).clone()); } catch (CloneNotSupportedException ex) { throw new DdlException(ex); } } boolean caseSensitive = delimitedIdentifierModeOn; for (int idx = 0; idx < targetTable.getIndexCount(); idx++) { IIndex targetIndex = targetTable.getIndex(idx); IIndex sourceIndex = sourceTable.findIndex(targetIndex.getName(), caseSensitive); if (sourceIndex != null) { if ((caseSensitive && sourceIndex.equals(targetIndex)) || (!caseSensitive && sourceIndex.equalsIgnoreCase(targetIndex))) { table.addIndex(targetIndex); } } } return table; } /** * Writes a statement that copies the data from the source to the target * table. Note that this copies only those columns that are in both tables. * Database-specific implementations might redefine this method though they * usually it suffices to redefine the * {@link #writeCastExpression(Column, Column)} method. * * @param sourceTable * The source table * @param targetTable * The target table */ public void writeCopyDataStatement(Table sourceTable, Table targetTable, StringBuilder ddl) { LinkedHashMap<Column, Column> columnMap = getCopyDataColumnMapping(sourceTable, targetTable); writeCopyDataStatement(sourceTable, targetTable, columnMap, ddl); } public void writeCopyDataStatement(Table sourceTable, Table targetTable, LinkedHashMap<Column, Column> columnMap, StringBuilder ddl) { ddl.append("INSERT INTO "); ddl.append(getFullyQualifiedTableNameShorten(targetTable)); ddl.append(" ("); for (Iterator<Column> columnIt = columnMap.values().iterator(); columnIt.hasNext();) { printIdentifier(getColumnName((Column) columnIt.next()), ddl); if (columnIt.hasNext()) { ddl.append(","); } } ddl.append(") SELECT "); for (Iterator<Map.Entry<Column, Column>> columnsIt = columnMap.entrySet().iterator(); columnsIt .hasNext();) { Map.Entry<Column, Column> entry = columnsIt.next(); writeCastExpression((Column) entry.getKey(), (Column) entry.getValue(), ddl); if (columnsIt.hasNext()) { ddl.append(","); } } ddl.append(" FROM "); ddl.append(getFullyQualifiedTableNameShorten(sourceTable)); printEndOfStatement(ddl); } public LinkedHashMap<Column, Column> getCopyDataColumnMapping(Table sourceTable, Table targetTable) { LinkedHashMap<Column, Column> columns = new LinkedHashMap<Column, Column>(); for (int idx = 0; idx < sourceTable.getColumnCount(); idx++) { Column sourceColumn = sourceTable.getColumn(idx); Column targetColumn = targetTable.findColumn(sourceColumn.getName(), delimitedIdentifierModeOn); if (targetColumn != null) { columns.put(sourceColumn, targetColumn); } } return columns; } public LinkedHashMap<Column, Column> getCopyDataColumnOrderedMapping(Table sourceTable, Table targetTable) { LinkedHashMap<Column, Column> columns = new LinkedHashMap<Column, Column>(); for (int idx = 0; idx < sourceTable.getColumnCount(); idx++) { columns.put(sourceTable.getColumn(idx), targetTable.getColumn(idx)); } return columns; } /** * Writes a cast expression that converts the value of the source column to * the data type of the target column. Per default, simply the name of the * source column is written thereby assuming that any casts happen * implicitly. */ protected void writeCastExpression(Column sourceColumn, Column targetColumn, StringBuilder ddl) { printIdentifier(getColumnName(sourceColumn), ddl); } /** * Processes the addition of a primary key to a table. */ protected void processChange(Database currentModel, Database desiredModel, AddPrimaryKeyChange change, StringBuilder ddl) { writeExternalPrimaryKeysCreateStmt(change.getChangedTable(), change.getPrimaryKeyColumns(), ddl); change.apply(currentModel, delimitedIdentifierModeOn); } /** * Searches in the given table for a corresponding foreign key. If the given * key has no name, then a foreign key to the same table with the same * columns in the same order is searched. If the given key has a name, then * the a corresponding key also needs to have the same name, or no name at * all, but not a different one. * * @param table * The table to search in * @param fk * The original foreign key * @return The corresponding foreign key if found */ protected ForeignKey findCorrespondingForeignKey(Table table, ForeignKey fk) { boolean caseMatters = delimitedIdentifierModeOn; boolean checkFkName = (fk.getName() != null) && (fk.getName().length() > 0); Reference[] refs = fk.getReferences(); ArrayList<Reference> curRefs = new ArrayList<Reference>(); for (int fkIdx = 0; fkIdx < table.getForeignKeyCount(); fkIdx++) { ForeignKey curFk = table.getForeignKey(fkIdx); boolean checkCurFkName = checkFkName && (curFk.getName() != null) && (curFk.getName().length() > 0); if ((!checkCurFkName || areEqual(fk.getName(), curFk.getName(), caseMatters)) && areEqual(fk.getForeignTableName(), curFk.getForeignTableName(), caseMatters)) { curRefs.clear(); CollectionUtils.addAll(curRefs, curFk.getReferences()); // the order is not fixed, so we have to take this long way if (curRefs.size() == refs.length) { for (int refIdx = 0; refIdx < refs.length; refIdx++) { boolean found = false; for (int curRefIdx = 0; !found && (curRefIdx < curRefs.size()); curRefIdx++) { Reference curRef = curRefs.get(curRefIdx); if ((caseMatters && refs[refIdx].equals(curRef)) || (!caseMatters && refs[refIdx].equalsIgnoreCase(curRef))) { curRefs.remove(curRefIdx); found = true; } } } if (curRefs.isEmpty()) { return curFk; } } } } return null; } /** * Compares the two strings. * * @param string1 * The first string * @param string2 * The second string * @param caseMatters * Whether case matters in the comparison * @return <code>true</code> if the string are equal */ protected boolean areEqual(String string1, String string2, boolean caseMatters) { return (caseMatters && string1.equals(string2)) || (!caseMatters && string1.equalsIgnoreCase(string2)); } /** * Outputs the DDL to create the table along with any non-external * constraints as well as with external primary keys and indices (but not * foreign keys). */ public String createTable(Table table) { StringBuilder ddl = new StringBuilder(); createTable(table, ddl, false, false); return ddl.toString(); } /** * Outputs the DDL to create the table along with any non-external * constraints as well as with external primary keys and indices (but not * foreign keys). * @param recreate TODO */ protected void createTable(Table table, StringBuilder ddl, boolean temporary, boolean recreate) { writeTableCreationStmt(table, ddl); writeTableCreationStmtEnding(table, ddl); if (!databaseInfo.isIndicesEmbedded()) { writeExternalIndicesCreateStmt(table, ddl); } if (!databaseInfo.isPrimaryKeyEmbedded()) { writeExternalPrimaryKeysCreateStmt(table, table.getPrimaryKeyColumns(), ddl); } } /** * Creates the external foreignkey creation statements for all tables in the * database. * * @param database * The database */ public void createExternalForeignKeys(Database database, StringBuilder ddl) { for (int idx = 0; idx < database.getTableCount(); idx++) { createExternalForeignKeys(database, database.getTable(idx), ddl); } } /** * Creates external foreign key creation statements if necessary. */ public void createExternalForeignKeys(Database database, Table table, StringBuilder ddl) { if (!databaseInfo.isForeignKeysEmbedded()) { for (int idx = 0; idx < table.getForeignKeyCount(); idx++) { writeExternalForeignKeyCreateStmt(database, table, table.getForeignKey(idx), ddl); } } } public String dropTables(Database database) { StringBuilder ddl = new StringBuilder(); dropTables(database, ddl); return ddl.toString(); } /** * Outputs the DDL required to drop the database. */ public void dropTables(Database database, StringBuilder ddl) { // we're dropping the external foreign keys first for (int idx = database.getTableCount() - 1; idx >= 0; idx--) { Table table = database.getTable(idx); if ((table.getName() != null) && (table.getName().length() > 0)) { dropExternalForeignKeys(table, ddl); } } // Next we drop the tables in reverse order to avoid referencial // problems // TODO: It might be more useful to either (or both) // * determine an order in which the tables can be dropped safely (via // the foreignkeys) // * alter the tables first to drop the internal foreignkeys for (int idx = database.getTableCount() - 1; idx >= 0; idx--) { Table table = database.getTable(idx); if ((table.getName() != null) && (table.getName().length() > 0)) { writeTableComment(table, ddl); dropTable(table, ddl, false, false); } } } /** * Outputs the DDL required to drop the given table. This method also drops * foreign keys to the table. */ public void dropTable(Database database, Table table, StringBuilder ddl) { // we're dropping the foreignkeys to the table first for (int idx = database.getTableCount() - 1; idx >= 0; idx--) { Table otherTable = database.getTable(idx); ForeignKey[] fks = otherTable.getForeignKeys(); for (int fkIdx = 0; (fks != null) && (fkIdx < fks.length); fkIdx++) { if (fks[fkIdx].getForeignTable().equals(table)) { writeExternalForeignKeyDropStmt(otherTable, fks[fkIdx], ddl); } } } // and the foreign keys from the table dropExternalForeignKeys(table, ddl); writeTableComment(table, ddl); dropTable(table, ddl, false, false); } /** * Outputs the DDL to drop the table. Note that this method does not drop * foreign keys to this table. Use {@link #dropTable(Database, Table)} if * you want that. * @param recreate TODO */ protected void dropTable(Table table, StringBuilder ddl, boolean temporary, boolean recreate) { ddl.append("DROP TABLE "); ddl.append(getFullyQualifiedTableNameShorten(table)); printEndOfStatement(ddl); } /** * Creates external foreign key drop statements. * * @param table * The table */ public void dropExternalForeignKeys(Table table, StringBuilder ddl) { if (!databaseInfo.isForeignKeysEmbedded()) { for (int idx = 0; idx < table.getForeignKeyCount(); idx++) { writeExternalForeignKeyDropStmt(table, table.getForeignKey(idx), ddl); } } } /** * Creates the SQL for inserting an object into the specified table. If * values are given then a concrete insert statement is created, otherwise * an insert statement usable in a prepared statement is build. * * @param table * The table * @param columnValues * The columns values indexed by the column names * @param genPlaceholders * Whether to generate value placeholders for a prepared * statement * @return The insertion sql */ public String getInsertSql(Table table, Map<String, Object> columnValues, boolean genPlaceholders) { StringBuffer buffer = new StringBuffer("INSERT INTO "); boolean addComma = false; buffer.append(getFullyQualifiedTableNameShorten(table)); buffer.append(" ("); for (int idx = 0; idx < table.getColumnCount(); idx++) { Column column = table.getColumn(idx); if (columnValues.containsKey(column.getName())) { if (addComma) { buffer.append(", "); } buffer.append(getDelimitedIdentifier(column.getName())); addComma = true; } } buffer.append(") VALUES ("); if (genPlaceholders) { addComma = false; for (int idx = 0; idx < columnValues.size(); idx++) { if (addComma) { buffer.append(", "); } buffer.append("?"); addComma = true; } } else { addComma = false; for (int idx = 0; idx < table.getColumnCount(); idx++) { Column column = table.getColumn(idx); if (columnValues.containsKey(column.getName())) { if (addComma) { buffer.append(", "); } buffer.append(getValueAsString(column, columnValues.get(column.getName()))); addComma = true; } } } buffer.append(")"); return buffer.toString(); } /** * Creates the SQL for updating an object in the specified table. If values * are given then a concrete update statement is created, otherwise an * update statement usable in a prepared statement is build. * * @param table * The table * @param columnValues * Contains the values for the columns to update, and should also * contain the primary key values to identify the object to * update in case <code>genPlaceholders</code> is * <code>false</code> * @param genPlaceholders * Whether to generate value placeholders for a prepared * statement (both for the pk values and the object values) * @return The update sql */ public String getUpdateSql(Table table, Map<String, Object> columnValues, boolean genPlaceholders) { StringBuffer buffer = new StringBuffer("UPDATE "); boolean addSep = false; buffer.append(getFullyQualifiedTableNameShorten(table)); buffer.append(" SET "); for (int idx = 0; idx < table.getColumnCount(); idx++) { Column column = table.getColumn(idx); if (!column.isPrimaryKey() && columnValues.containsKey(column.getName())) { if (addSep) { buffer.append(", "); } buffer.append(getDelimitedIdentifier(column.getName())); buffer.append(" = "); if (genPlaceholders) { buffer.append("?"); } else { buffer.append(getValueAsString(column, columnValues.get(column.getName()))); } addSep = true; } } buffer.append(" WHERE "); addSep = false; for (int idx = 0; idx < table.getColumnCount(); idx++) { Column column = table.getColumn(idx); if (column.isPrimaryKey() && columnValues.containsKey(column.getName())) { if (addSep) { buffer.append(" AND "); } buffer.append(getDelimitedIdentifier(column.getName())); buffer.append(" = "); if (genPlaceholders) { buffer.append("?"); } else { buffer.append(getValueAsString(column, columnValues.get(column.getName()))); } addSep = true; } } return buffer.toString(); } /** * Creates the SQL for deleting an object from the specified table. If * values are given then a concrete delete statement is created, otherwise * an delete statement usable in a prepared statement is build. * * @param table * The table * @param pkValues * The primary key values indexed by the column names, can be * empty * @param genPlaceholders * Whether to generate value placeholders for a prepared * statement * @return The delete sql */ public String getDeleteSql(Table table, Map<String, Object> pkValues, boolean genPlaceholders) { StringBuffer buffer = new StringBuffer("DELETE FROM "); boolean addSep = false; buffer.append(getFullyQualifiedTableNameShorten(table)); if ((pkValues != null) && !pkValues.isEmpty()) { buffer.append(" WHERE "); for (Iterator<Map.Entry<String, Object>> it = pkValues.entrySet().iterator(); it.hasNext();) { Map.Entry<String, Object> entry = it.next(); Column column = table.findColumn((String) entry.getKey()); if (addSep) { buffer.append(" AND "); } buffer.append(getDelimitedIdentifier(entry.getKey().toString())); buffer.append(" = "); if (genPlaceholders) { buffer.append("?"); } else { buffer.append(column == null ? entry.getValue() : getValueAsString(column, entry.getValue())); } addSep = true; } } return buffer.toString(); } /** * Generates the string representation of the given value. * * @param column * The column * @param value * The value * @return The string representation */ protected String getValueAsString(Column column, Object value) { if (value == null) { return "NULL"; } StringBuffer result = new StringBuffer(); // TODO: Handle binary types (BINARY, VARBINARY, LONGVARBINARY, BLOB) switch (column.getMappedTypeCode()) { case Types.DATE: result.append(databaseInfo.getValueQuoteToken()); if (!(value instanceof String) && (getValueDateFormat() != null)) { // TODO: Can the format method handle java.sql.Date properly // ? result.append(getValueDateFormat().format(value)); } else { result.append(value.toString()); } result.append(databaseInfo.getValueQuoteToken()); break; case Types.TIME: result.append(databaseInfo.getValueQuoteToken()); if (!(value instanceof String) && (getValueTimeFormat() != null)) { // TODO: Can the format method handle java.sql.Date properly // ? result.append(getValueTimeFormat().format(value)); } else { result.append(value.toString()); } result.append(databaseInfo.getValueQuoteToken()); break; case Types.TIMESTAMP: result.append(databaseInfo.getValueQuoteToken()); // TODO: SimpleDateFormat does not support nano seconds so we // would // need a custom date formatter for timestamps result.append(value.toString()); result.append(databaseInfo.getValueQuoteToken()); break; case Types.REAL: case Types.NUMERIC: case Types.FLOAT: case Types.DOUBLE: case Types.DECIMAL: result.append(databaseInfo.getValueQuoteToken()); if (!(value instanceof String) && (getValueNumberFormat() != null)) { result.append(getValueNumberFormat().format(value)); } else { result.append(value.toString()); } result.append(databaseInfo.getValueQuoteToken()); break; default: result.append(databaseInfo.getValueQuoteToken()); result.append(escapeStringValue(value.toString())); result.append(databaseInfo.getValueQuoteToken()); break; } return result.toString(); } /** * Generates the SQL for querying the id that was created in the last * insertion operation. This is obviously only useful for pk fields that are * auto-incrementing. A database that does not support this, will return * <code>null</code>. * * @param table * The table * @return The sql, or <code>null</code> if the database does not support * this */ public String getSelectLastIdentityValues(Table table) { // No default possible as the databases are quite different in this // respect return null; } /** * Generates the SQL to execute that sets the current sequence number. * * @param table * @param id * @return */ public String fixLastIdentityValues(Table table) { return null; } public void writeFixLastIdentityValues(Table table, StringBuilder ddl) { String sql = fixLastIdentityValues(table); if (sql != null) { ddl.append(sql); printEndOfStatement(ddl); } } /** * Generates a version of the name that has at most the specified length. * * @param name * The original name * @param desiredLength * The desired maximum length * @return The shortened version */ public String shortenName(String name, int desiredLength) { // TODO: Find an algorithm that generates unique names int originalLength = name.length(); if ((desiredLength <= 0) || (originalLength <= desiredLength)) { return name; } int delta = originalLength - desiredLength; int startCut = desiredLength / 2; StringBuffer result = new StringBuffer(); result.append(name.substring(0, startCut)); if (((startCut == 0) || (name.charAt(startCut - 1) != '_')) && ((startCut + delta + 1 == originalLength) || (name.charAt(startCut + delta + 1) != '_'))) { // just to make sure that there isn't already a '_' right before or // right // after the cutting place (which would look odd with an aditional // one) result.append("_"); } result.append(name.substring(startCut + delta + 1, originalLength)); return result.toString(); } /** * Returns the table name. This method takes care of length limitations * imposed by some databases. * * @param table * The table * @return The table name */ public String getTableName(String tableName) { return shortenName(tableName, databaseInfo.getMaxTableNameLength()); } /** * Outputs a comment for the table. * * @param table * The table */ protected void writeTableComment(Table table, StringBuilder ddl) { printComment("-----------------------------------------------------------------------", ddl); printComment(getFullyQualifiedTableNameShorten(table), ddl); printComment("-----------------------------------------------------------------------", ddl); println(ddl); } /** * Generates the first part of the ALTER TABLE statement including the table * name. * * @param table * The table being altered */ protected void writeTableAlterStmt(Table table, StringBuilder ddl) { ddl.append("ALTER TABLE "); ddl.append(getFullyQualifiedTableNameShorten(table)); println(ddl); printIndent(ddl); } /** * Writes the table creation statement without the statement end. */ protected void writeTableCreationStmt(Table table, StringBuilder ddl) { ddl.append("CREATE TABLE "); //TODO Check side effect with shortened name table ddl.append(getFullyQualifiedTableNameShorten(table)); println("(", ddl); writeColumns(table, ddl); if (databaseInfo.isPrimaryKeyEmbedded()) { writeEmbeddedPrimaryKeysStmt(table, ddl); } if (databaseInfo.isForeignKeysEmbedded()) { writeEmbeddedForeignKeysStmt(table, ddl); } if (databaseInfo.isIndicesEmbedded()) { writeEmbeddedIndicesStmt(table, ddl); } println(ddl); ddl.append(")"); if (isSpecifyIdentityGapLimit()) { writeIdentityGapLimit(ddl); } } /** * Writes the end of table statement indicating an identity gap maximum value. */ protected void writeIdentityGapLimit(StringBuilder ddl) { int gapSize = getGapLimitSize(); ddl.append(" with identity_gap = " + gapSize); } /** * Should the identity gap maximum size be specified in table create statements. */ protected static boolean isSpecifyIdentityGapLimit() { return "true".equalsIgnoreCase(System.getProperty("org.jumpmind.symmetric.ddl.gap.limit", "false")); } /** * Get the maximum identity gap size from the property. */ protected static int getGapLimitSize() { return Integer.valueOf(System.getProperty("org.jumpmind.symmetric.ddl.gap.max", "10000")); } /** * Writes the end of the table creation statement. Per default, only the end * of the statement is written, but this can be changed in subclasses. * * @param table * The table */ protected void writeTableCreationStmtEnding(Table table, StringBuilder ddl) { printEndOfStatement(ddl); } /** * Writes the columns of the given table. */ protected void writeColumns(Table table, StringBuilder ddl) { for (int idx = 0; idx < table.getColumnCount(); idx++) { printIndent(ddl); writeColumn(table, table.getColumn(idx), ddl); if (idx < table.getColumnCount() - 1) { println(",", ddl); } } } /** * Returns the column name. This method takes care of length limitations * imposed by some databases. * * @param column * The column * @return The column name */ protected String getColumnName(Column column) { return shortenName(column.getName(), databaseInfo.getMaxColumnNameLength()); } protected void writeColumnTypeDefaultRequired(Table table, Column column, StringBuilder ddl) { // see comments in columnsDiffer about null/"" defaults printIdentifier(getColumnName(column), ddl); ddl.append(" "); writeColumnType(table, column, ddl); } public String getColumnTypeDdl(Table table, Column column) { StringBuilder ddl = new StringBuilder(); writeColumnType(table, column, ddl); return ddl.toString(); } protected void writeColumnType(Table table, Column column, StringBuilder ddl) { ddl.append(getSqlType(column)); writeColumnDefaultValueStmt(table, column, ddl); if (column.isRequired()) { ddl.append(" "); writeColumnNotNullableStmt(ddl); } else if (databaseInfo.isNullAsDefaultValueRequired() && databaseInfo.hasNullDefault(column.getMappedTypeCode())) { ddl.append(" "); writeColumnNullableStmt(ddl); } } /** * Outputs the DDL for the specified column. */ protected void writeColumn(Table table, Column column, StringBuilder ddl) { writeColumnTypeDefaultRequired(table, column, ddl); if (column.isPrimaryKey() && databaseInfo.isPrimaryKeyEmbedded()) { writeColumnEmbeddedPrimaryKey(table, column, ddl); } if (column.isAutoIncrement() && !databaseInfo.isDefaultValueUsedForIdentitySpec()) { if (!databaseInfo.isNonPKIdentityColumnsSupported() && !column.isPrimaryKey()) { throw new ModelException("Column " + column.getName() + " in table " + table.getName() + " is auto-incrementing but not a primary key column, which is not supported by the platform"); } ddl.append(" "); writeColumnAutoIncrementStmt(table, column, ddl); } } protected void writeColumnEmbeddedPrimaryKey(Table table, Column column, StringBuilder ddl) { } /** * Returns the full SQL type specification (including size and * precision/scale) for the given column. * * @param column * The column * @return The full SQL type string including the size */ protected String getSqlType(Column column) { PlatformColumn platformColumn = column.findPlatformColumn(databaseName); String nativeType = getNativeType(column); if (platformColumn != null) { nativeType = platformColumn.getType(); } int sizePos = nativeType.indexOf(SIZE_PLACEHOLDER); StringBuilder sqlType = new StringBuilder(); sqlType.append(sizePos >= 0 ? nativeType.substring(0, sizePos) : nativeType); Integer size = column.getSizeAsInt(); if (platformColumn != null) { size = platformColumn.getSize(); } if ((size == null || size == 0) && platformColumn == null) { size = databaseInfo.getDefaultSize(column.getMappedTypeCode()); } int scale = column.getScale(); if (platformColumn != null) { scale = platformColumn.getDecimalDigits(); } if (size != null && size >= 0) { if (databaseInfo.hasSize(column.getMappedTypeCode())) { if (size > 0) { sqlType.append("("); sqlType.append(size.toString()); sqlType.append(")"); } } else if (databaseInfo.hasPrecisionAndScale(column.getMappedTypeCode())) { StringBuilder precisionAndScale = new StringBuilder(); precisionAndScale.append("("); precisionAndScale.append(size); if (scale >= 0) { precisionAndScale.append(","); precisionAndScale.append(scale); } precisionAndScale.append(")"); if (!"(0,0)".equals(precisionAndScale.toString())) { sqlType.append(precisionAndScale); } } } sqlType.append(sizePos >= 0 ? nativeType.substring(sizePos + SIZE_PLACEHOLDER.length()) : ""); filterColumnSqlType(sqlType); return sqlType.toString(); } protected void filterColumnSqlType(StringBuilder sqlType) { // Default is to not filter but allows subclasses to filter as needed. } /** * Returns the database-native type for the given column. * * @param column * The column * @return The native type */ protected String getNativeType(Column column) { String nativeType = (String) databaseInfo.getNativeType(column.getMappedTypeCode()); return nativeType == null ? column.getMappedType() : nativeType; } /** * Returns the bare database-native type for the given column without any * size specifies. * * @param column * The column * @return The native type */ protected String getBareNativeType(Column column) { String nativeType = getNativeType(column); int sizePos = nativeType.indexOf(SIZE_PLACEHOLDER); return sizePos >= 0 ? nativeType.substring(0, sizePos) : nativeType; } /** * Returns the native default value for the column. * * @param column * The column * @return The native default value */ protected String getNativeDefaultValue(Column column) { String defaultValue = column.getDefaultValue(); PlatformColumn platformColumn = column.findPlatformColumn(databaseName); if (platformColumn != null) { defaultValue = platformColumn.getDefaultValue(); } return defaultValue; } /** * Escapes the necessary characters in given string value. * * @param value * The value * @return The corresponding string with the special characters properly * escaped */ protected String escapeStringValue(String value) { String result = value; for (Iterator<Map.Entry<String, String>> it = charSequencesToEscape.entrySet().iterator(); it.hasNext();) { Map.Entry<String, String> entry = (Map.Entry<String, String>) it.next(); result = StringUtils.replace(result, entry.getKey(), entry.getValue()); } return result; } /** * Determines whether the given default spec is a non-empty spec that shall * be used in a DEFAULT expression. E.g. if the spec is an empty string and * the type is a numeric type, then it is no valid default value whereas if * it is a string type, then it is valid. * * @param defaultSpec * The default value spec * @param typeCode * The JDBC type code * @return <code>true</code> if the default value spec is valid */ protected boolean isValidDefaultValue(String defaultSpec, int typeCode) { return (defaultSpec != null) && ((defaultSpec.length() > 0) || (!TypeMap.isNumericType(typeCode) && !TypeMap.isDateTimeType(typeCode))); } /** * Prints the default value stmt part for the column. */ protected void writeColumnDefaultValueStmt(Table table, Column column, StringBuilder ddl) { Object parsedDefault = column.getParsedDefaultValue(); if (parsedDefault != null) { if (!databaseInfo.isDefaultValuesForLongTypesSupported() && ((column.getMappedTypeCode() == Types.LONGVARBINARY) || (column.getMappedTypeCode() == Types.LONGVARCHAR))) { throw new ModelException( "The platform does not support default values for LONGVARCHAR or LONGVARBINARY columns"); } // we write empty default value strings only if the type is not a // numeric or date/time type if (isValidDefaultValue(column.getDefaultValue(), column.getMappedTypeCode())) { ddl.append(" DEFAULT "); writeColumnDefaultValue(table, column, ddl); } } else if (databaseInfo.isDefaultValueUsedForIdentitySpec() && column.isAutoIncrement()) { // here? ddl.append(" DEFAULT "); writeColumnDefaultValue(table, column, ddl); } else if (!StringUtils.isBlank(column.getDefaultValue())) { ddl.append(" DEFAULT "); writeColumnDefaultValue(table, column, ddl); } } /** * Prints the default value of the column. */ protected void writeColumnDefaultValue(Table table, Column column, StringBuilder ddl) { printDefaultValue(getNativeDefaultValue(column), column.getMappedTypeCode(), ddl); } /** * Prints the default value of the column. */ protected void printDefaultValue(String defaultValue, int typeCode, StringBuilder ddl) { boolean isNull = false; if (defaultValue == null || defaultValue.equalsIgnoreCase("null")) { isNull = true; } String defaultValueStr = mapDefaultValue(defaultValue, typeCode); boolean shouldUseQuotes = !isNull && !TypeMap.isNumericType(typeCode) && !(TypeMap.isDateTimeType(typeCode) && (defaultValueStr.toUpperCase().startsWith("TO_DATE(") || defaultValueStr.toUpperCase().startsWith("SYSDATE") || defaultValueStr.toUpperCase().startsWith("SYSTIMESTAMP") || defaultValueStr.toUpperCase().startsWith("CURRENT_TIMESTAMP") || defaultValueStr.toUpperCase().startsWith("CURRENT_TIME") || defaultValueStr.toUpperCase().startsWith("CURRENT_DATE") || defaultValueStr.toUpperCase().startsWith("CURRENT_USER") || defaultValueStr.toUpperCase().startsWith("USER") || defaultValueStr.toUpperCase().startsWith("SYSTEM_USER") || defaultValueStr.toUpperCase().startsWith("SESSION_USER") || defaultValueStr.toUpperCase().startsWith("DATE '") || defaultValueStr.toUpperCase().startsWith("TIME '") || defaultValueStr.toUpperCase().startsWith("TIMESTAMP '") || defaultValueStr.toUpperCase().startsWith("INTERVAL '"))) && !(defaultValueStr.toUpperCase().startsWith("N'") && defaultValueStr.endsWith("'")); if (shouldUseQuotes) { // characters are only escaped when within a string literal ddl.append(databaseInfo.getValueQuoteToken()); ddl.append(escapeStringValue(defaultValueStr)); ddl.append(databaseInfo.getValueQuoteToken()); } else { ddl.append(defaultValueStr); } } protected String mapDefaultValue(Object defaultValue, int typeCode) { if (defaultValue == null) { defaultValue = "NULL"; } return defaultValue.toString(); } /** * Prints that the column is an auto increment column. */ protected void writeColumnAutoIncrementStmt(Table table, Column column, StringBuilder ddl) { ddl.append("IDENTITY"); } /** * Prints that a column is nullable. */ protected void writeColumnNullableStmt(StringBuilder ddl) { ddl.append("NULL"); } /** * Prints that a column is not nullable. */ protected void writeColumnNotNullableStmt(StringBuilder ddl) { ddl.append("NOT NULL"); } /** * Compares the current column in the database with the desired one. Type, * nullability, size, scale, default value, and precision radix are the * attributes checked. Currently default values are compared, and null and * empty string are considered equal. * * @param currentColumn * The current column as it is in the database * @param desiredColumn * The desired column * @return <code>true</code> if the column specifications differ */ protected boolean columnsDiffer(Column currentColumn, Column desiredColumn) { // The createColumn method leaves off the default clause if // column.getDefaultValue() // is null. mySQL interprets this as a default of "" or 0, and thus the // columns // are always different according to this method. alterDatabase will // generate // an alter statement for the column, but it will be the exact same // definition // as before. In order to avoid this situation I am ignoring the // comparison // if the desired default is null. In order to "un-default" a column // you'll // have to have a default="" or default="0" in the schema xml. // If this is bad for other databases, it is recommended that the // createColumn // method use a "DEFAULT NULL" statement if that is what is needed. // A good way to get this would be to require a defaultValue="<NULL>" in // the // schema xml if you really want null and not just unspecified. String desiredDefault = desiredColumn.getDefaultValue(); String currentDefault = currentColumn.getDefaultValue(); boolean defaultsEqual = (desiredDefault == null) || desiredDefault.equals(currentDefault); boolean sizeMatters = databaseInfo.hasSize(currentColumn.getMappedTypeCode()) && (desiredColumn.getSize() != null); // We're comparing the jdbc type that corresponds to the native type for // the // desired type, in order to avoid repeated altering of a perfectly // valid column if ((databaseInfo.getTargetJdbcType(desiredColumn.getMappedTypeCode()) != currentColumn.getMappedTypeCode()) || (desiredColumn.isRequired() != currentColumn.isRequired()) || (sizeMatters && !StringUtils.equals(desiredColumn.getSize(), currentColumn.getSize())) || !defaultsEqual) { return true; } else { return false; } } /** * Returns the name to be used for the given foreign key. If the foreign key * has no specified name, this method determines a unique name for it. The * name will also be shortened to honor the maximum identifier length * imposed by the platform. * * @param table * The table for whith the foreign key is defined * @param fk * The foreign key * @return The name */ public String getForeignKeyName(Table table, ForeignKey fk) { String fkName = fk.getName(); boolean needsName = (fkName == null) || (fkName.length() == 0); if (needsName) { StringBuffer name = new StringBuffer(); for (int idx = 0; idx < fk.getReferenceCount(); idx++) { name.append(fk.getReference(idx).getLocalColumnName()); name.append("_"); } name.append(fk.getForeignTableName()); fkName = getConstraintName(null, table, "FK", name.toString()); } fkName = shortenName(fkName, databaseInfo.getMaxForeignKeyNameLength()); if (needsName) { log.warn("Encountered a foreign key in table " + table.getName() + " that has no name. " + "DdlUtils will use the auto-generated and shortened name " + fkName + " instead."); } return fkName; } /** * Returns the constraint name. This method takes care of length limitations * imposed by some databases. * * @param prefix * The constraint prefix, can be <code>null</code> * @param table * The table that the constraint belongs to * @param secondPart * The second name part, e.g. the name of the constraint column * @param suffix * The constraint suffix, e.g. a counter (can be * <code>null</code>) * @return The constraint name */ public String getConstraintName(String prefix, Table table, String secondPart, String suffix) { StringBuffer result = new StringBuffer(); if (prefix != null) { result.append(prefix); result.append("_"); } result.append(table.getName()); result.append("_"); result.append(secondPart); if (suffix != null) { result.append("_"); result.append(suffix); } return shortenName(result.toString(), databaseInfo.getMaxConstraintNameLength()); } /** * Writes the primary key constraints of the table inside its definition. * * @param table * The table */ protected void writeEmbeddedPrimaryKeysStmt(Table table, StringBuilder ddl) { Column[] primaryKeyColumns = table.getPrimaryKeyColumns(); if ((primaryKeyColumns.length > 0) && shouldGeneratePrimaryKeys(primaryKeyColumns)) { printStartOfEmbeddedStatement(ddl); writePrimaryKeyStmt(table, primaryKeyColumns, ddl); } } /** * Writes the primary key constraints of the table as alter table * statements. * * @param table * The table * @param primaryKeyColumns * The primary key columns */ protected void writeExternalPrimaryKeysCreateStmt(Table table, Column[] primaryKeyColumns, StringBuilder ddl) { if ((primaryKeyColumns.length > 0) && shouldGeneratePrimaryKeys(primaryKeyColumns)) { ddl.append("ALTER TABLE "); ddl.append(getFullyQualifiedTableNameShorten(table)); println(ddl); printIndent(ddl); ddl.append("ADD CONSTRAINT "); printIdentifier(getConstraintName(null, table, "PK", null), ddl); ddl.append(" "); writePrimaryKeyStmt(table, primaryKeyColumns, ddl); printEndOfStatement(ddl); } } /** * Determines whether we should generate a primary key constraint for the * given primary key columns. * * @param primaryKeyColumns * The pk columns * @return <code>true</code> if a pk statement should be generated for the * columns */ protected boolean shouldGeneratePrimaryKeys(Column[] primaryKeyColumns) { return true; } /** * Writes a primary key statement for the given columns. * * @param table * The table * @param primaryKeyColumns * The primary columns */ protected void writePrimaryKeyStmt(Table table, Column[] primaryKeyColumns, StringBuilder ddl) { ddl.append("PRIMARY KEY ("); for (int idx = 0; idx < primaryKeyColumns.length; idx++) { printIdentifier(getColumnName(primaryKeyColumns[idx]), ddl); if (idx < primaryKeyColumns.length - 1) { ddl.append(", "); } } ddl.append(")"); } /** * Returns the index name. This method takes care of length limitations * imposed by some databases. * * @param index * The index * @return The index name */ public String getIndexName(IIndex index) { return shortenName(index.getName(), databaseInfo.getMaxConstraintNameLength()); } /** * Writes the indexes of the given table. * * @param table * The table */ protected void writeExternalIndicesCreateStmt(Table table, StringBuilder ddl) { for (int idx = 0; idx < table.getIndexCount(); idx++) { IIndex index = table.getIndex(idx); if (!index.isUnique() && !databaseInfo.isIndicesSupported()) { return; } writeExternalIndexCreateStmt(table, index, ddl); } } /** * Writes the indexes embedded within the create table statement. */ protected void writeEmbeddedIndicesStmt(Table table, StringBuilder ddl) { if (databaseInfo.isIndicesSupported()) { for (int idx = 0; idx < table.getIndexCount(); idx++) { printStartOfEmbeddedStatement(ddl); writeEmbeddedIndexCreateStmt(table, table.getIndex(idx), ddl); } } } /** * Writes the given index of the table. */ protected void writeExternalIndexCreateStmt(Table table, IIndex index, StringBuilder ddl) { if (databaseInfo.isIndicesSupported()) { if (index.getName() == null) { log.warn("Cannot write unnamed index " + index); } else { ddl.append("CREATE"); if (index.isUnique()) { ddl.append(" UNIQUE"); } ddl.append(" INDEX "); printIdentifier(getIndexName(index), ddl); ddl.append(" ON "); ddl.append(getFullyQualifiedTableNameShorten(table)); ddl.append(" ("); for (int idx = 0; idx < index.getColumnCount(); idx++) { IndexColumn idxColumn = index.getColumn(idx); Column col = table.findColumn(idxColumn.getName()); if (col == null) { // would get null pointer on next line anyway, so throw // exception throw new ModelException("Invalid column '" + idxColumn.getName() + "' on index " + index.getName() + " for table " + table.getName()); } if (idx > 0) { ddl.append(", "); } printIdentifier(getColumnName(col), ddl); } ddl.append(")"); printEndOfStatement(ddl); } } } /** * Writes the given embedded index of the table. */ protected void writeEmbeddedIndexCreateStmt(Table table, IIndex index, StringBuilder ddl) { if ((index.getName() != null) && (index.getName().length() > 0)) { ddl.append(" CONSTRAINT "); printIdentifier(getIndexName(index), ddl); } if (index.isUnique()) { ddl.append(" UNIQUE"); } else { ddl.append(" INDEX "); } ddl.append(" ("); for (int idx = 0; idx < index.getColumnCount(); idx++) { IndexColumn idxColumn = index.getColumn(idx); Column col = table.findColumn(idxColumn.getName()); if (col == null) { // would get null pointer on next line anyway, so throw // exception throw new ModelException("Invalid column '" + idxColumn.getName() + "' on index " + index.getName() + " for table " + table.getName()); } if (idx > 0) { ddl.append(", "); } printIdentifier(getColumnName(col), ddl); } ddl.append(")"); } /** * Generates the statement to drop a non-embedded index from the database. */ public void writeExternalIndexDropStmt(Table table, IIndex index, StringBuilder ddl) { if (databaseInfo.isAlterTableForDropUsed()) { writeTableAlterStmt(table, ddl); } ddl.append("DROP INDEX "); printIdentifier(getIndexName(index), ddl); if (!databaseInfo.isAlterTableForDropUsed()) { ddl.append(" ON "); ddl.append(getFullyQualifiedTableNameShorten(table)); } printEndOfStatement(ddl); } /** * Writes the foreign key constraints inside a create table () clause. */ protected void writeEmbeddedForeignKeysStmt(Table table, StringBuilder ddl) { for (int idx = 0; idx < table.getForeignKeyCount(); idx++) { ForeignKey key = table.getForeignKey(idx); if (key.getForeignTableName() == null) { log.warn("Foreign key table is null for key " + key); } else { printStartOfEmbeddedStatement(ddl); if (databaseInfo.isEmbeddedForeignKeysNamed()) { ddl.append("CONSTRAINT "); printIdentifier(getForeignKeyName(table, key), ddl); ddl.append(" "); } ddl.append("FOREIGN KEY ("); writeLocalReferences(key, ddl); ddl.append(") REFERENCES "); if (StringUtils.isNotBlank(table.getCatalog())) { ddl.append(getDelimitedIdentifier(table.getCatalog())).append("."); } if (StringUtils.isNotBlank(table.getSchema())) { ddl.append(getDelimitedIdentifier(table.getSchema())).append("."); } printIdentifier(getTableName(key.getForeignTableName()), ddl); ddl.append(" ("); writeForeignReferences(key, ddl); ddl.append(")"); } } } /** * Writes a single foreign key constraint using a alter table statement. * * @param database * The database model * @param table * The table * @param key * The foreign key */ protected void writeExternalForeignKeyCreateStmt(Database database, Table table, ForeignKey key, StringBuilder ddl) { if (key.getForeignTableName() == null) { log.warn("Foreign key table is null for key " + key); } else { writeTableAlterStmt(table, ddl); ddl.append("ADD CONSTRAINT "); printIdentifier(getForeignKeyName(table, key), ddl); ddl.append(" FOREIGN KEY ("); writeLocalReferences(key, ddl); ddl.append(") REFERENCES "); // TODO: use getDelimitedIdentifier() around catalog/schema, but we'll need to get the case right // TODO : use same catalog and schema than table because catalog and schema are not present in table object if (StringUtils.isNotBlank(table.getCatalog())) { ddl.append(table.getCatalog()).append("."); } if (StringUtils.isNotBlank(table.getSchema())) { ddl.append(table.getSchema()).append("."); } printIdentifier(getTableName(key.getForeignTableName()), ddl); ddl.append(" ("); writeForeignReferences(key, ddl); ddl.append(")"); printEndOfStatement(ddl); } } /** * Writes a list of local references for the given foreign key. * * @param key * The foreign key */ protected void writeLocalReferences(ForeignKey key, StringBuilder ddl) { for (int idx = 0; idx < key.getReferenceCount(); idx++) { if (idx > 0) { ddl.append(", "); } printIdentifier(key.getReference(idx).getLocalColumnName(), ddl); } } /** * Writes a list of foreign references for the given foreign key. * * @param key * The foreign key */ protected void writeForeignReferences(ForeignKey key, StringBuilder ddl) { for (int idx = 0; idx < key.getReferenceCount(); idx++) { if (idx > 0) { ddl.append(", "); } printIdentifier(key.getReference(idx).getForeignColumnName(), ddl); } } /** * Generates the statement to drop a foreignkey constraint from the database * using an alter table statement. * * @param table * The table * @param foreignKey * The foreign key */ protected void writeExternalForeignKeyDropStmt(Table table, ForeignKey foreignKey, StringBuilder ddl) { writeTableAlterStmt(table, ddl); ddl.append("DROP CONSTRAINT "); printIdentifier(getForeignKeyName(table, foreignKey), ddl); printEndOfStatement(ddl); } /** * Prints an SQL comment to the current stream. * * @param text * The comment text */ protected void printComment(String text, StringBuilder ddl) { if (sqlCommentsOn) { ddl.append(databaseInfo.getCommentPrefix()); // Some databases insist on a space after the prefix ddl.append(" "); ddl.append(text); ddl.append(" "); ddl.append(databaseInfo.getCommentSuffix()); println(ddl); } } /** * Prints the start of an embedded statement. */ protected void printStartOfEmbeddedStatement(StringBuilder ddl) { println(",", ddl); printIndent(ddl); } /** * Prints the end of statement text, which is typically a semi colon * followed by a carriage return. */ protected void printEndOfStatement(StringBuilder ddl) { println(databaseInfo.getSqlCommandDelimiter(), ddl); } /** * Prints a newline. */ protected void println(StringBuilder ddl) { ddl.append(LINE_SEPARATOR); } /** * Returns the delimited version of the identifier (if configured). * * @param identifier * The identifier * @return The delimited version of the identifier unless the platform is * configured to use undelimited identifiers; in that case, the * identifier is returned unchanged */ protected String getDelimitedIdentifier(String identifier) { if (delimitedIdentifierModeOn) { return databaseInfo.getDelimiterToken() + identifier + databaseInfo.getDelimiterToken(); } else { return identifier; } } /** * Prints the given identifier. For most databases, this will be a delimited * identifier. * * @param identifier * The identifier */ protected void printIdentifier(String identifier, StringBuilder ddl) { ddl.append(getDelimitedIdentifier(identifier)); } /** * Prints the given identifier followed by a newline. For most databases, * this will be a delimited identifier. * * @param identifier * The identifier */ protected void printlnIdentifier(String identifier, StringBuilder ddl) { println(getDelimitedIdentifier(identifier), ddl); } /** * Prints some text followed by a newline. * * @param text * The text to print */ protected void println(String text, StringBuilder ddl) { ddl.append(text); println(ddl); } /** * Prints the characters used to indent SQL. */ protected void printIndent(StringBuilder ddl) { ddl.append(getIndent()); } /* * Determines whether script mode is on. This means that the generated SQL * is not intended to be sent directly to the database but rather to be * saved in a SQL script file. Per default, script mode is off. * * @return <code>true</code> if script mode is on */ public boolean isScriptModeOn() { return scriptModeOn; } /* * Specifies whether script mode is on. This means that the generated SQL is * not intended to be sent directly to the database but rather to be saved * in a SQL script file. * * @param scriptModeOn <code>true</code> if script mode is on */ public void setScriptModeOn(boolean scriptModeOn) { this.scriptModeOn = scriptModeOn; } /* * Determines whether SQL comments are generated. * * @return <code>true</code> if SQL comments shall be generated */ public boolean isSqlCommentsOn() { return sqlCommentsOn; } /* * Specifies whether SQL comments shall be generated. * * @param sqlCommentsOn <code>true</code> if SQL comments shall be generated */ public void setSqlCommentsOn(boolean sqlCommentsOn) { if (!databaseInfo.isSqlCommentsSupported() && sqlCommentsOn) { throw new DdlException("Platform does not support SQL comments"); } this.sqlCommentsOn = sqlCommentsOn; } /* * Determines whether delimited identifiers are used or normal SQL92 * identifiers (which may only contain alphanumerical characters and the * underscore, must start with a letter and cannot be a reserved keyword). * * @return <code>true</code> if delimited identifiers are used */ public boolean isDelimitedIdentifierModeOn() { return delimitedIdentifierModeOn; } /* * Specifies whether delimited identifiers are used or normal SQL92 * identifiers. * * @param delimitedIdentifierModeOn <code>true</code> if delimited * identifiers shall be used */ public void setDelimitedIdentifierModeOn(boolean delimitedIdentifierModeOn) { if (!databaseInfo.isDelimitedIdentifiersSupported() && delimitedIdentifierModeOn) { log.info("Platform does not support delimited identifier. Delimited identifiers will not be enabled."); } else { this.delimitedIdentifierModeOn = delimitedIdentifierModeOn; } } public DatabaseInfo getDatabaseInfo() { return databaseInfo; } }