/ - Diff - EDIT - EDIT Project Management

     import eu.etaxonomy.cdm.database.ICdmDataSource;
     /**
      * Base class for a {@link ISchemaUpdaterStep schema update step} which supports automated handling
      * Base class for a {@link ISchemaUpdaterStep schema update step} which supports automated handling
      * of auditing tables.
+     *
+     *
      * @see CdmUpdater
      * @see ISchemaUpdater
+     *
+     *
      * @author a.mueller
+     *
      * @param <T>
-...
     	protected boolean includeAudTable;
     	protected boolean isAuditing;
     	/**
     	 * Constructor
     	 * @param stepName
     	 */
     	protected AuditedSchemaUpdaterStepBase(String stepName) {
     		super(stepName);
+    	}
         protected AuditedSchemaUpdaterStepBase(String stepName, boolean includedAudTable) {
             super(stepName);
             this.includeAudTable = includedAudTable;
+        }
         protected AuditedSchemaUpdaterStepBase(String stepName, String tableName, boolean includedAudTable) {
             super(stepName);
             this.includeAudTable = includedAudTable;
             this.tableName = tableName;
+        }
     	@Override
     	public Integer invoke(ICdmDataSource datasource, IProgressMonitor monitor, CaseType caseType) throws SQLException {
-...
+    		}
     		return (result == true )? 0 : null;
+    	}
     	/**
     	 * Invoke the update on the given table of name tableName.
     	 * @param tableName the tableName, already in the correct case

     package eu.etaxonomy.cdm.database.update;
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.List;
     import org.apache.commons.lang.StringUtils;
     import org.apache.log4j.Logger;
     import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
-...
     public class ClassBaseTypeUpdater extends AuditedSchemaUpdaterStepBase<ClassBaseTypeUpdater> implements ISchemaUpdaterStep {
     	@SuppressWarnings("unused")
     	private static final Logger logger = Logger.getLogger(TableCreator.class);
     	private static final boolean SORT_INDEX = true;
     	private boolean includeIdentifiableEntity;
     	private boolean includeAnnotatableEntity;
     	private final boolean includeIdentifiableEntity;
     	private final boolean includeAnnotatableEntity;
     	protected List<ISchemaUpdaterStep> mnTablesStepList = new ArrayList<ISchemaUpdaterStep>();
     	protected List<ISchemaUpdaterStep> columnAdderStepList = new ArrayList<ISchemaUpdaterStep>();
     	public static final ClassBaseTypeUpdater NewVersionableToAnnotatableInstance(String stepName, String tableName, boolean includeAudTable){
     		return new ClassBaseTypeUpdater(stepName, tableName, includeAudTable, true, false);
+    	}
-...
     	public static final ClassBaseTypeUpdater NewVersionableToIdentifiableInstance(String stepName, String tableName, boolean includeAudTable){
     		return new ClassBaseTypeUpdater(stepName, tableName, includeAudTable, true, true);
+    	}
     	protected ClassBaseTypeUpdater(String stepName, String tableName, boolean includeAudit, boolean includeAnnotatable, boolean includeIdentifiable) {
     		super(stepName);
     		this.tableName = tableName;
     		this.includeAudTable = includeAudit;
     		super(stepName, tableName, includeAudit);
     		this.includeAnnotatableEntity = includeAnnotatable;
     		this.includeIdentifiableEntity = includeIdentifiable;
     		TableCreator.makeMnTables(mnTablesStepList, tableName, includeAnnotatable, includeIdentifiable);
     		makeColumns();
+    	}
     	private void makeColumns() {
     		String innerStepName;
     		String newColumnName;
     		ColumnAdder adder;
     		if (this.includeIdentifiableEntity){
     			//lsid authority
     			innerStepName = "-add lsid_authority";
     			newColumnName = "lsid_authority";
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     					newColumnName, SchemaUpdaterBase.INCLUDE_AUDIT);
     			this.columnAdderStepList.add(adder);
     			//lsid lsid
     			innerStepName = "-add lsid_lsid";
     			newColumnName = "lsid_lsid";
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     					newColumnName, SchemaUpdaterBase.INCLUDE_AUDIT);
     			this.columnAdderStepList.add(adder);
     			//lsid namespace
     			innerStepName = "-add lsid_namespace";
     			newColumnName = "lsid_namespace";
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     					newColumnName, SchemaUpdaterBase.INCLUDE_AUDIT);
     			this.columnAdderStepList.add(adder);
     			//lsid object
     			innerStepName = "-add lsid_object";
     			newColumnName = "lsid_object";
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     					newColumnName, SchemaUpdaterBase.INCLUDE_AUDIT);
     			this.columnAdderStepList.add(adder);
     			//lsid revision
     			innerStepName = "-add lsid_revision";
     			newColumnName = "lsid_revision";
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     					newColumnName, SchemaUpdaterBase.INCLUDE_AUDIT);
     			this.columnAdderStepList.add(adder);
     			//protected title cache
     			innerStepName = "-add protected title cache";
     			newColumnName = "protectedTitleCache";
     			adder = ColumnAdder.NewBooleanInstance(innerStepName, tableName, newColumnName,
     					SchemaUpdaterBase.INCLUDE_AUDIT, false);
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     					newColumnName, SchemaUpdaterBase.INCLUDE_AUDIT);
     			this.columnAdderStepList.add(adder);
     			this.columnAdderStepList.add(adder);
     			//title cache
     			innerStepName = "-add titleCache";
     			newColumnName = "titleCache";
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     			adder = ColumnAdder.NewStringInstance(stepName + innerStepName, tableName,
     					newColumnName, SchemaUpdaterBase.INCLUDE_AUDIT);
     			this.columnAdderStepList.add(adder);
+    		}
+    	}
     	@Override
     	protected boolean invokeOnTable(String tableName, ICdmDataSource datasource, IProgressMonitor monitor, CaseType caseType)  {
     		//we only do have inner steps here
     		return true;
+    	}
     	@Override
     	public List<ISchemaUpdaterStep> getInnerSteps() {
-...
     		result.addAll(columnAdderStepList);
     		return result;
+    	}
+    }

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
     public class ClassChanger extends AuditedSchemaUpdaterStepBase<ClassChanger> implements ISchemaUpdaterStep {
     	private static final Logger logger = Logger.getLogger(ClassChanger.class);
     	private String newClassName;
     	private String[] oldClassNames;
     	private boolean isIdentifiable;
     	private boolean isAnnotatable;
     	private boolean isSourcable;
     	private final String newClassName;
     	private final String[] oldClassNames;
     	private final boolean isIdentifiable;
     	private final boolean isAnnotatable;
     	private final boolean isSourcable;
     	public static final ClassChanger NewIdentifiableInstance(String stepName, String tableName, String newClassNamePath, String[] oldClassNames, boolean includeAudTable){
     		return new ClassChanger(stepName, tableName, newClassNamePath, oldClassNames, includeAudTable, true, true, true);
-...
     	public static final ClassChanger NewDescriptionElementInstance(String stepName, String tableName, String newClassNamePath, String[] oldClassNames, boolean includeAudTable){
     		return new ClassChanger(stepName, tableName, newClassNamePath, oldClassNames, includeAudTable, true, true, false);
+    	}
     	protected ClassChanger(String stepName, String tableName, String newClassName, String[] oldClassNames, boolean includeAudTable, boolean isAnnotatable, boolean isSourcable, boolean isIdentifiable) {
     		super(stepName);
     		this.tableName = tableName;
     		super(stepName, tableName, includeAudTable);
     		this.newClassName = newClassName;
     		this.oldClassNames = oldClassNames;
     		this.includeAudTable = includeAudTable;
     		this.isIdentifiable = isIdentifiable;
     		this.isAnnotatable = isAnnotatable;
     		this.isSourcable = isSourcable;
-...
     				String updateQuery = getDtypeUpdateQueryString(tableName, datasource, monitor);
     				datasource.executeUpdate(updateQuery);
+    			}
     			if (isAnnotatable){
     				updateAnnotatables(tableName, datasource, monitor, caseType);
+    			}
     			if (isSourcable){
     				updateSourcable(tableName, datasource, monitor, caseType);
+    			}
     			if (isIdentifiable){
     				updateIdentifiables(tableName, datasource, monitor, caseType);
+    			}
     			return result;
     		} catch ( Exception e) {
     			monitor.warning(e.getMessage(), e);
-...
     		String sql = " UPDATE %s " +
     				" SET %s = '%s' " +
     				" WHERE %s = '%s'";
     		for (String oldClassPath : oldClassNames){
     			String query = String.format(sql, caseType.transformTo(extensionClass),
     					typeAttr, newClassName,
     			String query = String.format(sql, caseType.transformTo(extensionClass),
     					typeAttr, newClassName,
     					typeAttr, oldClassPath);
     			datasource.executeUpdate(query);
+    		}
+    	}
     	public String getDtypeUpdateQueryString(String tableName, ICdmDataSource datasource, IProgressMonitor monitor) throws DatabaseTypeNotSupportedException {
     		String updateQuery;
     		updateQuery = " UPDATE @tableName " +
     		updateQuery = " UPDATE @tableName " +
     				" SET DTYPE = '@newTableName' " +
     				" WHERE (1=0 @dtypes)";
     		updateQuery = updateQuery.replace("@tableName", tableName);
     		updateQuery = updateQuery.replace("@newTableName", getSimpleName(newClassName));
     		String dtypes = "";
-...
     			dtypes += String.format(" OR DTYPE = '%s' ", getSimpleName(oldClassName)) ;
+    		}
     		updateQuery = updateQuery.replace("@dtypes", dtypes);
     		return updateQuery;
+    	}
     	private String getSimpleName(String className) {

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
      */
     public class ColumnAdder extends AuditedSchemaUpdaterStepBase<ColumnAdder> implements ISchemaUpdaterStep {
     	private static final Logger logger = Logger.getLogger(ColumnAdder.class);
     	private String newColumnName;
     	private String columnType;
     	private Object defaultValue;
     	private final String newColumnName;
     	private final String columnType;
     	private final Object defaultValue;
     	private boolean isNotNull;
     	private String referencedTable;
     	private final String referencedTable;
     	public static final ColumnAdder NewIntegerInstance(String stepName, String tableName, String newColumnName, boolean includeAudTable, boolean notNull, String referencedTable){
     		return new ColumnAdder(stepName, tableName, newColumnName, "int", includeAudTable, null, notNull, referencedTable);
+    	}
     	public static final ColumnAdder NewIntegerInstance(String stepName, String tableName, String newColumnName, boolean includeAudTable, Integer defaultValue, boolean notNull){
     		return new ColumnAdder(stepName, tableName, newColumnName, "int", includeAudTable, defaultValue, notNull, null);
+    	}
     	public static final ColumnAdder NewTinyIntegerInstance(String stepName, String tableName, String newColumnName, boolean includeAudTable, boolean notNull){
     		return new ColumnAdder(stepName, tableName, newColumnName, "tinyint", includeAudTable, null, notNull, null);
+    	}
     	public static final ColumnAdder NewDoubleInstance(String stepName, String tableName, String newColumnName, boolean includeAudTable, boolean notNull){
     		return new ColumnAdder(stepName, tableName, newColumnName, "double", includeAudTable, null, notNull, null);
+    	}
-...
     	public static final ColumnAdder NewBooleanInstance(String stepName, String tableName, String newColumnName, boolean includeAudTable, Boolean defaultValue){
     		return new ColumnAdder(stepName, tableName, newColumnName, "bit", includeAudTable, defaultValue, false, null);
+    	}
     	public static final ColumnAdder NewStringInstance(String stepName, String tableName, String newColumnName, boolean includeAudTable){
     		return new ColumnAdder(stepName, tableName, newColumnName, "nvarchar(255)", includeAudTable, null, false, null);
+    	}
-...
     	public static final ColumnAdder NewClobInstance(String stepName, String tableName, String newColumnName, boolean includeAudTable){
     		return new ColumnAdder(stepName, tableName, newColumnName, "clob", includeAudTable, null, false, null);
+    	}
     	public static final ColumnAdder NewDateTimeInstance(String stepName, String tableName, String newColumnName, boolean includeAudTable, boolean notNull){
     		return new ColumnAdder(stepName, tableName, newColumnName, "datetime", includeAudTable, null, notNull, null);
+    	}
     	protected ColumnAdder(String stepName, String tableName, String newColumnName, String columnType, boolean includeAudTable, Object defaultValue, boolean notNull, String referencedTable) {
     		super(stepName);
     		this.tableName = tableName;
     		super(stepName, tableName, includeAudTable);
     		this.newColumnName = newColumnName;
     		this.columnType = columnType;
     		this.includeAudTable = includeAudTable;
     		this.defaultValue = defaultValue;
     		this.isNotNull = notNull;
     		this.referencedTable = referencedTable;
-...
     		try {
     			String updateQuery = getUpdateQueryString(tableName, datasource, monitor);
     			datasource.executeUpdate(updateQuery);
     			if (defaultValue instanceof Boolean){
     				String defaultValueQuery = "UPDATE @tableName SET @columnName = " + (defaultValue == null ? "NULL" : getBoolean((Boolean) defaultValue, datasource));
     				defaultValueQuery = defaultValueQuery.replace("@tableName", tableName);
-...
     			if (referencedTable != null){
     				result &= TableCreator.makeForeignKey(tableName, datasource, monitor, newColumnName, referencedTable, caseType);
+    			}
     			return result;
     		} catch ( Exception e) {
     			monitor.warning(e.getMessage(), e);
-...
+    	}
     	/**
     	 * Returns the update query string. tableName must already be cased correctly. See {@link CaseType}.
     	 * Returns the update query string. tableName must already be cased correctly. See {@link CaseType}.
     	 * @param tableName correctly cased table name
     	 * @param datasource data source
     	 * @param monitor monitor
     	 * @return the query string
     	 * @return the query string
     	 * @throws DatabaseTypeNotSupportedException
     	 */
     	public String getUpdateQueryString(String tableName, ICdmDataSource datasource, IProgressMonitor monitor) throws DatabaseTypeNotSupportedException {
-...
     		updateQuery = updateQuery.replace("@columnName", newColumnName);
     		updateQuery = updateQuery.replace("@columnType", databaseColumnType);
     		updateQuery = updateQuery.replace("@addSeparator", getAddColumnSeperator(datasource));
     		return updateQuery;
+    	}
-...
+    		}
     		return result;
+    	}
     	/**
     	 * Returns the sql keywords for adding a column. This is usually 'ADD' or 'ADD COLUMN'
-...
     	public String getReferencedTable() {
     		return referencedTable;
+    	}
     	public String getNewColumnName() {
     		return newColumnName;

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
      */
     public class ColumnNameChanger extends AuditedSchemaUpdaterStepBase<ColumnNameChanger> implements ISchemaUpdaterStep {
     	private static final Logger logger = Logger.getLogger(ColumnNameChanger.class);
     	private String newColumnName;
     	private String oldColumnName;
     	private Datatype datatype; //TODO make enum
     	private final String newColumnName;
     	private final String oldColumnName;
     	private final Datatype datatype; //TODO make enum
     	private enum Datatype{
     		integer,
     		clob
+    	}
     	public static ColumnNameChanger NewIntegerInstance(String stepName, String tableName, String oldColumnName, String newColumnName, boolean includeAudTable){
     		return new ColumnNameChanger(stepName, tableName, oldColumnName, newColumnName, includeAudTable, null, Datatype.integer);
+    	}
     	public static ColumnNameChanger NewClobInstance(String stepName, String tableName, String oldColumnName, String newColumnName, boolean includeAudTable){
     		return new ColumnNameChanger(stepName, tableName, oldColumnName, newColumnName, includeAudTable, null, Datatype.clob);
+    	}
     	protected ColumnNameChanger(String stepName, String tableName, String oldColumnName, String newColumnName, boolean includeAudTable, Object defaultValue, Datatype datatype) {
     		super(stepName);
     		this.tableName = tableName;
     		super(stepName, tableName, includeAudTable);
     		this.newColumnName = newColumnName;
     		this.oldColumnName = oldColumnName;
     		this.includeAudTable = includeAudTable;
     		this.datatype = datatype;
+    	}
-...
     			boolean result = true;
     			DatabaseTypeEnum type = datasource.getDatabaseType();
     			String updateQuery;
     			if (type.equals(DatabaseTypeEnum.SqlServer2005)){
     				logger.warn("SQLServer column name changer syntax not yet tested");
     				updateQuery = "EXEC sp_rename '@oldName', '@newName'";
-...
     			updateQuery = updateQuery.replace("@newColumnName", newColumnName);
     			updateQuery = updateQuery.replace("@definition", getDefinition());
     			datasource.executeUpdate(updateQuery);
     			return result;
     		} catch (Exception e) {
     			monitor.warning(e.getMessage(), e);

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
      */
     public class ColumnRemover extends AuditedSchemaUpdaterStepBase<ColumnRemover> implements ISchemaUpdaterStep {
     	private static final Logger logger = Logger.getLogger(ColumnRemover.class);
     	private String oldColumnName;
     	private final String oldColumnName;
     	public static final ColumnRemover NewInstance(String stepName, String tableName, String oldColumnName, boolean includeAudTable){
     		return new ColumnRemover(stepName, tableName, oldColumnName, includeAudTable);
+    	}
     	protected ColumnRemover(String stepName, String tableName, String oldColumnName, boolean includeAudTable) {
     		super(stepName);
     		this.tableName = tableName;
     		super(stepName, tableName, includeAudTable);
     		this.oldColumnName = oldColumnName;
     		this.includeAudTable = includeAudTable;
+    	}
     	@Override
-...
     	public String getUpdateQueryString(String tableName, ICdmDataSource datasource, IProgressMonitor monitor) throws DatabaseTypeNotSupportedException {
     		String updateQuery;
     		DatabaseTypeEnum type = datasource.getDatabaseType();
     		updateQuery = "ALTER TABLE @tableName DROP COLUMN @columnName";
     		if (type.equals(DatabaseTypeEnum.SqlServer2005)){
     			//MySQL allows both syntaxes
-...
+    		}
     		updateQuery = updateQuery.replace("@tableName", tableName);
     		updateQuery = updateQuery.replace("@columnName", oldColumnName);
     		return updateQuery;
+    	}

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
      */
     public class ColumnTypeChanger extends AuditedSchemaUpdaterStepBase<ColumnTypeChanger> implements ISchemaUpdaterStep {
     	private static final Logger logger = Logger.getLogger(ColumnTypeChanger.class);
     	private String columnName;
     	private String newColumnType;
     	private Object defaultValue;
     	private boolean isNotNull;
     	private String referencedTable;
     	private final String columnName;
     	private final String newColumnType;
     	private final Object defaultValue;
     	private final boolean isNotNull;
     	private final String referencedTable;
     	public static final ColumnTypeChanger NewStringSizeInstance(String stepName, String tableName, String columnName, int newSize, boolean includeAudTable){
     		return new ColumnTypeChanger(stepName, tableName, columnName, "nvarchar("+newSize+")", includeAudTable, null, false, null);
+    	}
     	public static final ColumnTypeChanger NewClobInstance(String stepName, String tableName, String columnName, boolean includeAudTable){
     		return new ColumnTypeChanger(stepName, tableName, columnName, "clob", includeAudTable, null, false, null);
+    	}
     	public static final ColumnTypeChanger NewInt2DoubleInstance(String stepName, String tableName, String columnName, boolean includeAudTable){
     		return new ColumnTypeChanger(stepName, tableName, columnName, "double", includeAudTable, null, false, null);
+    	}
-...
     	public static final ColumnTypeChanger NewInt2StringInstance(String stepName, String tableName, String columnName, int size, boolean includeAudTable, Integer defaultValue, boolean notNull){
     		return new ColumnTypeChanger(stepName, tableName, columnName, "nvarchar("+size+")", includeAudTable, defaultValue, notNull, null);
+    	}
     //	public static final ColumnTypeChanger NewChangeAllowNullOnStringChanger(){
     //
     //
     //	}
     	protected ColumnTypeChanger(String stepName, String tableName, String columnName, String newColumnType, boolean includeAudTable, Object defaultValue, boolean notNull, String referencedTable) {
     		super(stepName);
     		this.tableName = tableName;
     		super(stepName, tableName, includeAudTable);
     		this.columnName = columnName;
     		this.newColumnType = newColumnType;
     		this.includeAudTable = includeAudTable;
     		this.defaultValue = defaultValue;
     		this.isNotNull = notNull;
     		this.referencedTable = referencedTable;
-...
     	protected boolean invokeOnTable(String tableName, ICdmDataSource datasource, IProgressMonitor monitor, CaseType caseType) {
     		boolean result = true;
     		try {
     			String updateQuery;
     			if (this.isNotNull){
     				updateQuery = getNotNullUpdateQuery(tableName, datasource, monitor);
     				datasource.executeUpdate(updateQuery);
+    			}
     			updateQuery = getUpdateQueryString(tableName, datasource, monitor);
     			datasource.executeUpdate(updateQuery);
     			if (defaultValue instanceof Boolean){
     				updateQuery = "UPDATE @tableName SET @columnName = " + (defaultValue == null ? "null" : getBoolean((Boolean) defaultValue, datasource));
     				updateQuery = updateQuery.replace("@tableName", tableName);
-...
     			if (referencedTable != null){
     				result &= TableCreator.makeForeignKey(tableName, datasource, monitor, columnName, referencedTable, caseType);
+    			}
     			return result;
     		} catch ( Exception e) {
     			monitor.warning(e.getMessage(), e);
-...
     		updateQuery = updateQuery.replace("@columnName", columnName);
     		updateQuery = updateQuery.replace("@columnType", databaseColumnType);
     //		updateQuery = updateQuery.replace("@addSeparator", getAddColumnSeperator(datasource));
     		return updateQuery;
+    	}
     	private String getDatabaseColumnType(ICdmDataSource datasource, String columnType) {
     		return ColumnAdder.getDatabaseColumnType(datasource, columnType);
+    	}
     	public String getReferencedTable() {
     		return referencedTable;
+    	}

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
     import eu.etaxonomy.cdm.database.ICdmDataSource;
     /**
      * This class represents one step in a schema update.
      * This class represents one step in a schema update.
      * @author a.mueller
      * @date 13.09.2010
+     *
      */
     public class SimpleSchemaUpdaterStep extends SchemaUpdaterStepBase<SimpleSchemaUpdaterStep> implements ISchemaUpdaterStep, ITermUpdaterStep{
     	private static final Logger logger = Logger.getLogger(SimpleSchemaUpdaterStep.class);
     	private Map<DatabaseTypeEnum, String> queryMap = new HashMap<DatabaseTypeEnum, String>();
     	private Map<DatabaseTypeEnum, String> auditQueryMap = new HashMap<DatabaseTypeEnum, String>();
     	private final Map<DatabaseTypeEnum, String> queryMap = new HashMap<DatabaseTypeEnum, String>();
     	private final Map<DatabaseTypeEnum, String> auditQueryMap = new HashMap<DatabaseTypeEnum, String>();
     	private boolean includeAudit = false;
     //	private String tableName;
     // *************************** FACTORY ********************************/
     	/**
     	 * @deprecated use  {@link #NewNonAuditedInstance(String, String)},
     	 * {@link #NewAuditedInstance(String, String, boolean, String)},
     	 * @deprecated use  {@link #NewNonAuditedInstance(String, String)},
     	 * {@link #NewAuditedInstance(String, String, boolean, String)},
     	 * or {@link #NewExplicitAuditedInstance(String, String, String)} instead
     	 */
     	@Deprecated
     	public static SimpleSchemaUpdaterStep NewInstance(String stepName, String defaultQuery, int adapt){
     		return new SimpleSchemaUpdaterStep(stepName, defaultQuery, false, null, null);
+    	}
     	public static SimpleSchemaUpdaterStep NewNonAuditedInstance(String stepName, String defaultQuery, int adapt){
     		return new SimpleSchemaUpdaterStep(stepName, defaultQuery, false, null, null);
+    	}
-...
     	/**
     	 * @param stepName Step name
     	 * @param defaultQuery query
     	 * @param nonAuditedTableName the name of the non audited table. E.g. TaxonNameBase (whild TaxonNameBase_AUD is the audited table
     	 * @param nonAuditedTableName the name of the non audited table. E.g. TaxonNameBase
     	 *     (while TaxonNameBase_AUD is the audited table
     	 * @param adapt preliminary
     	 * @return
     	 */
-...
     		return new SimpleSchemaUpdaterStep(stepName, defaultQuery, audit, null, defaultQueryForAuditedTables);
+    	}
     //************************ CONSTRUCTOR ***********************************/
     	private SimpleSchemaUpdaterStep(String stepName, String defaultQuery, boolean includeAudit, String tableName, String defaultQueryForAuditedTables){
     		super(stepName);
     		this.includeAudit = includeAudit;
     		queryMap.put(null, defaultQuery);
     		if (includeAudit){
     			if (StringUtils.isNotBlank(defaultQueryForAuditedTables)){
     				auditQueryMap.put(null, defaultQueryForAuditedTables);
-...
+    			}
+    		}
+    	}
     // *************************** INVOKE *****************************
     // *************************** INVOKE *****************************
     	@Override
     	public Integer invoke (ICdmDataSource datasource, IProgressMonitor monitor, CaseType caseType){
     		boolean result = true;
     		//non audit
     		result &= invokeQueryMap(datasource, queryMap, caseType); ;
     		//audit
-...
     		}else{
     			logger.info("SimpleSchemaUpdaterStep non Audited");
+    		}
     		return (result == true )? 0 : null;
+    	}
-...
+    		}
     		return true;
+    	}
     	private void makeAuditedQuery(DatabaseTypeEnum dbType, String tableName){
     		String nonAuditQuery = this.queryMap.get(dbType);
     		if (StringUtils.isBlank(nonAuditQuery)){
-...
+    	}
     //********************************* DELEGATES *********************************/
     	/**
     	 * For certain database types one may define special queries.<BR>
     	 * Don't forget to put case-mask (@@) for table names
     	 * @param dbType database type
     	 * @param query query to use for the given database type.
     	 * @return this schema updater step
     	 * @return this schema updater step
     	 */
     	public SimpleSchemaUpdaterStep put(DatabaseTypeEnum dbType, String query) {
     		queryMap.put(dbType, query);
-...
     		makeAuditedQuery(null, nonAuditedTableName);
     		return this;
+    	}
+    }

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
      */
     public class TableCreator extends AuditedSchemaUpdaterStepBase<TableCreator> implements ISchemaUpdaterStep {
     	private static final Logger logger = Logger.getLogger(TableCreator.class);
     	private static final boolean SORT_INDEX = true;
     	private List<String> columnNames;
     	private List<String> columnTypes;
     	private List<Object> defaultValues;
     	private List<Boolean> isNotNull;
     	private List<String> referencedTables;
     	private boolean includeCdmBaseAttributes;
     	private boolean includeIdentifiableEntity;
     	private boolean includeAnnotatableEntity;
     	private final List<String> columnNames;
     	private final List<String> columnTypes;
     	private final List<Object> defaultValues;
     	private final List<Boolean> isNotNull;
     	private final List<String> referencedTables;
     	private final boolean includeCdmBaseAttributes;
     	private final boolean includeIdentifiableEntity;
     	private final boolean includeAnnotatableEntity;
     	private boolean includeEventBase;
     	private boolean excludeVersionableAttributes;
     	private final boolean excludeVersionableAttributes;
     	protected List<ColumnAdder> columnAdders = new ArrayList<ColumnAdder>();
     	protected List<ISchemaUpdaterStep> mnTablesStepList = new ArrayList<ISchemaUpdaterStep>();
     	private String primaryKeyParams;
-...
     	private String uniqueParams;
     	private String uniqueParams_AUD;
     //	public static final TableCreator NewInstance(String stepName, String tableName, List<String> columnNames, List<String> columnTypes, List<Object> defaultValues, List<Boolean> isNull, boolean includeAudTable){
     	public static final TableCreator NewInstance(String stepName, String tableName, List<String> columnNames, List<String> columnTypes, boolean includeAudTable, boolean includeCdmBaseAttributes){
     		return new TableCreator(stepName, tableName, columnNames, columnTypes, null, null, null, includeAudTable, includeCdmBaseAttributes, false, false, false);
+    	}
     	public static final TableCreator NewInstance(String stepName, String tableName, String[] columnNames, String[] columnTypes, String[] referencedTables, boolean includeAudTable, boolean includeCdmBaseAttributes){
     		return new TableCreator(stepName, tableName, Arrays.asList(columnNames), Arrays.asList(columnTypes), null, null, Arrays.asList(referencedTables), includeAudTable, includeCdmBaseAttributes, false, false, false);
+    	}
     	public static final TableCreator NewNonVersionableInstance(String stepName, String tableName, String[] columnNames, String[] columnTypes, String[] referencedTables){
     		return new TableCreator(stepName, tableName, Arrays.asList(columnNames), Arrays.asList(columnTypes), null, null, Arrays.asList(referencedTables), false, true, false, false, true);
+    	}
     	public static final TableCreator NewVersionableInstance(String stepName, String tableName, String[] columnNames, String[] columnTypes, String[] referencedTables, boolean includeAudTable){
     		return new TableCreator(stepName, tableName, Arrays.asList(columnNames), Arrays.asList(columnTypes), null, null, Arrays.asList(referencedTables), includeAudTable, true, false, false, false);
+    	}
     	public static final TableCreator NewAnnotatableInstance(String stepName, String tableName, String[] columnNames, String[] columnTypes, String[] referencedTables, boolean includeAudTable){
     		return new TableCreator(stepName, tableName, Arrays.asList(columnNames), Arrays.asList(columnTypes), null, null, Arrays.asList(referencedTables), includeAudTable, true, true, false, false);
+    	}
     	public static final TableCreator NewEventInstance(String stepName, String tableName, String[] columnNames, String[] columnTypes, String[] referencedTables, boolean includeAudTable){
     		TableCreator result = new TableCreator(stepName, tableName, Arrays.asList(columnNames), Arrays.asList(columnTypes), null, null, Arrays.asList(referencedTables), includeAudTable, true, true, false, false);
     		result.includeEventBase = true;
     		return result;
+    	}
     	public static final TableCreator NewIdentifiableInstance(String stepName, String tableName, String[] columnNames, String[] columnTypes, String[] referencedTables, boolean includeAudTable){
     		return new TableCreator(stepName, tableName, Arrays.asList(columnNames), Arrays.asList(columnTypes), null, null, Arrays.asList(referencedTables), includeAudTable, true, true, true, false);
+    	}
     	protected TableCreator(String stepName, String tableName, List<String> columnNames, List<String> columnTypes, List<Object> defaultValues, List<Boolean> isNotNull, List<String> referencedTables,
     	protected TableCreator(String stepName, String tableName, List<String> columnNames, List<String> columnTypes, List<Object> defaultValues, List<Boolean> isNotNull, List<String> referencedTables,
     			boolean includeAudTable, boolean includeCdmBaseAttributes, boolean includeAnnotatableEntity, boolean includeIdentifiableEntity, boolean excludeVersionableAttributes) {
     		super(stepName);
     		this.tableName = tableName;
     		super(stepName, tableName, includeAudTable);
     		this.columnNames = columnNames;
     		this.columnTypes = columnTypes;
     		this.defaultValues = defaultValues;
     		this.isNotNull = isNotNull;
     		this.referencedTables = referencedTables;
     		this.includeAudTable = includeAudTable;
     		this.includeCdmBaseAttributes = includeCdmBaseAttributes;
     		this.includeAnnotatableEntity = includeAnnotatableEntity;
     		this.includeIdentifiableEntity = includeIdentifiableEntity;
-...
     		if (columnNames.size() != columnTypes.size()){
     			throw new RuntimeException ("ColumnNames and columnTypes must be of same size. Step: " + getStepName());
+    		}
     		try {
     			for (int i = 0; i < columnNames.size(); i++){
     				boolean isNotNull = this.isNotNull == null ? false : this.isNotNull.get(i);
-...
     			throw new RuntimeException(e);
+    		}
+    	}
     	/**
     	 * fills the mnTablesStepList
     	 * @param mnTablesStepList, String tableName
     	 * @param mnTablesStepList, String tableName
     	 */
     	public static void makeMnTables(List<ISchemaUpdaterStep> mnTablesStepList, String tableName, boolean includeAnnotatable, boolean includeIdentifiable) {
     		TableCreator tableCreator;
     		String stepName;
     		if (includeAnnotatable){
     			//annotations
     			stepName= "Add @tableName annotations";
-...
     			stepName = stepName.replace("@tableName", tableName);
     			tableCreator = MnTableCreator.NewMnInstance(stepName, tableName, "Marker", SchemaUpdaterBase.INCLUDE_AUDIT);
     			mnTablesStepList.add(tableCreator);
+    		}
     		if (includeIdentifiable){
     			//credits
-...
     			stepName = stepName.replace("@tableName", tableName);
     			tableCreator = MnTableCreator.NewMnInstance(stepName, tableName, null, "Credit", null, SchemaUpdaterBase.INCLUDE_AUDIT, SORT_INDEX, false);
     			mnTablesStepList.add(tableCreator);
     			//identifier
     			stepName= "Add @tableName identifiers";
     			stepName = stepName.replace("@tableName", tableName);
     			tableCreator = MnTableCreator.NewMnInstance(stepName, tableName, null, "Identifier", null, SchemaUpdaterBase.INCLUDE_AUDIT, SORT_INDEX, false);
     			mnTablesStepList.add(tableCreator);
     			//extensions
     			stepName= "Add @tableName extensions";
     			stepName = stepName.replace("@tableName", tableName);
     			tableCreator = MnTableCreator.NewMnInstance(stepName, tableName, "Extension", SchemaUpdaterBase.INCLUDE_AUDIT);
     			mnTablesStepList.add(tableCreator);
     			//OriginalSourceBase
     			stepName= "Add @tableName sources";
     			stepName = stepName.replace("@tableName", tableName);
-...
+    			}
     			//specific columns
     			updateQuery += 	getColumnsSql(tableName, datasource, monitor);
     			//primary and unique keys
     			String primaryKeySql = primaryKey(isAuditing)==null ? "" : "primary key (" + primaryKey(isAuditing) + "),";
     			String uniqueSql = unique(isAuditing)== null ? "" : "unique(" + unique(isAuditing) + "),";
     			updateQuery += primaryKeySql + uniqueSql;
     			//finalize
     			updateQuery = StringUtils.chomp(updateQuery.trim(), ",") + ")";
     			//replace
     			updateQuery = updateQuery.replace("@tableName", tableName);
     			//append datasource specific string
     			updateQuery += datasource.getDatabaseType().getHibernateDialect().getTableTypeString();
     			logger.debug("UPDATE Query: " + updateQuery);
     			//execute
     			datasource.executeUpdate(updateQuery);
     			//Foreign Keys
     			result &= createForeignKeys(tableName, isAuditing, datasource, monitor, caseType);
     			return result;
     		} catch (Exception e) {
     			monitor.warning(e.getMessage(), e);
-...
     		String result = "";
     		for (ColumnAdder adder : this.columnAdders){
     			String singleAdderSQL = adder.getUpdateQueryString(tableName, datasource, monitor) + ", ";
     			String[] split = singleAdderSQL.split(ColumnAdder.getAddColumnSeperator(datasource));
     			result += split[1];
+    		}
     		return result;
+    	}
     	private boolean createForeignKeys(String tableName, boolean isAudit, ICdmDataSource datasource, IProgressMonitor monitor, CaseType caseType) throws SQLException {
     		boolean result = true;
     		if (includeCdmBaseAttributes){
-...
     				String referencedTable = "UserAccount";
     				result &= makeForeignKey(tableName, datasource, monitor, attribute, referencedTable, caseType);
+    			}
     			String attribute = "createdby";
     			String referencedTable = "UserAccount";
     			result &= makeForeignKey(tableName, datasource, monitor, attribute, referencedTable, caseType);
     			result &= makeForeignKey(tableName, datasource, monitor, attribute, referencedTable, caseType);
+    		}
     		if (isAudit){
     			String attribute = "REV";
-...
+    		}
     		for (ColumnAdder adder : this.columnAdders){
     			if (adder.getReferencedTable() != null){
     				result &= makeForeignKey(tableName, datasource, monitor, adder.getNewColumnName(), adder.getReferencedTable(), caseType);
     				result &= makeForeignKey(tableName, datasource, monitor, adder.getNewColumnName(), adder.getReferencedTable(), caseType);
+    			}
+    		}
     		return result;
-...
     	public static boolean makeForeignKey(String tableName, ICdmDataSource datasource, IProgressMonitor monitor, String attribute, String referencedTable, CaseType caseType) throws SQLException {
     		boolean result = true;
     		referencedTable = caseType.transformTo(referencedTable);
     		if (supportsForeignKeys(datasource, monitor, tableName, referencedTable)){
     			String index = "FK@tableName_@attribute";
     			index = index.replace("@tableName", tableName);
     			index = index.replace("@attribute", attribute);
     			String idSuffix = "_id";
     			if (isRevAttribute(attribute) || attribute.endsWith(idSuffix)){
     				idSuffix = "";
-...
     			}else{
     				updateQuery = updateQuery.replace("@constraintName", "");  //H2 does not support "CONSTRAINT", didn't check for others
+    			}
     			if (isRevAttribute(attribute)){
     				updateQuery = updateQuery.replace("@id", "revisionnumber");
     			}else{
-...
     				logger.warn(message, e);
     				return true;   //we do not interrupt update if only foreign key generation did not work
+    			}
     			return result;
     			return result;
     		}else{
     			return true;
+    		}
-...
     			} catch (Exception e) {
     				String message = "Problems to determine table engine for MySQL.";
     				monitor.warning(message);
     				return true;  //default
     				return true;  //default
+    			}
+    		}
+    	}
     	private static boolean isRevAttribute(String attribute) {
-...
     	 */
     	protected String primaryKey(boolean isAudit){
     		String result = null;
     		if (! isAudit && this.primaryKeyParams != null){
     		if (! isAudit && this.primaryKeyParams != null){
     			return this.primaryKeyParams;
     		}else if (isAudit && this.primaryKeyParams_AUD != null){
     		}else if (isAudit && this.primaryKeyParams_AUD != null){
     			return this.primaryKeyParams_AUD;
+    		}
+    		}
     		if (includeCdmBaseAttributes || ! includeCdmBaseAttributes){ //TODO how to handle not CDMBase includes
     			if (! isAudit){
-...
+    		}
     		return result;
+    	}
     	/**
     	 * Constructs the unique key creation string
     	 * @param isAudit

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
      */
     public class TableDroper extends AuditedSchemaUpdaterStepBase<TableDroper> implements ISchemaUpdaterStep {
     	private static final Logger logger = Logger.getLogger(TableDroper.class);
     	private boolean ifExists = true;
     	public static final TableDroper NewInstance(String stepName, String tableName, boolean includeAudTable){
     		return new TableDroper(stepName, tableName, includeAudTable, true);
+    	}
     	/**
     	 * @param stepName
     	 * @param tableName
-...
     		return new TableDroper(stepName, tableName, includeAudTable, ifExists);
+    	}
     	protected TableDroper(String stepName, String tableName, boolean includeAudTable, boolean ifExists) {
     		super(stepName);
     		this.tableName = tableName;
     		this.includeAudTable = includeAudTable;
     		super(stepName, tableName, includeAudTable);
     		this.ifExists = ifExists;
+    	}
-...
     			logger.error(message);
     			return false;
+    		}
+    	}
     	/**
-...
     	public String getUpdateQueryString(String tableName, ICdmDataSource datasource, IProgressMonitor monitor) throws DatabaseTypeNotSupportedException {
     		String updateQuery;
     		DatabaseTypeEnum type = datasource.getDatabaseType();
     		updateQuery = "DROP TABLE @ifExists @tableName ";
     		if (type.equals(DatabaseTypeEnum.SqlServer2005)){
     			//MySQL allows both syntaxes
-...
     		}else{
     			updateQuery = updateQuery.replace("@ifExists", "");
+    		}
     		return updateQuery;
+    	}

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
      */
     public class TreeIndexUpdater extends AuditedSchemaUpdaterStepBase<TreeIndexUpdater> implements ISchemaUpdaterStep {
     	private static final Logger logger = Logger.getLogger(TreeIndexUpdater.class);
     	private String indexColumnName = "treeIndex";
     	private String treeIdColumnName;
     	private String parentIdColumnName = "parent_id";
     	private final String treeIdColumnName;
     	private final String parentIdColumnName = "parent_id";
     	public static final TreeIndexUpdater NewInstance(String stepName, String tableName, String treeIdColumnName, boolean includeAudTable){
     		return new TreeIndexUpdater(stepName, tableName, treeIdColumnName, null, includeAudTable);
+    	}
-...
     	public static final TreeIndexUpdater NewInstance(String stepName, String tableName, String treeIdColumnName, String indexColumnName, boolean includeAudTable){
     		return new TreeIndexUpdater(stepName, tableName, treeIdColumnName, indexColumnName, includeAudTable);
+    	}
     	protected TreeIndexUpdater(String stepName, String tableName, String treeIdColumnName, String indexColumnName, boolean includeAudTable) {
     		super(stepName);
     		this.tableName = tableName;
     		super(stepName, tableName, includeAudTable);
     		this.treeIdColumnName = treeIdColumnName;
     		this.indexColumnName = indexColumnName == null ? this.indexColumnName : indexColumnName;
     		this.includeAudTable = includeAudTable;
+    	}
     	@Override
     	protected boolean invokeOnTable(String tableName, ICdmDataSource datasource, IProgressMonitor monitor, CaseType caseType) {
     		try{
     			boolean result = true;
     			boolean result = true;
     	//		String charType = "CHAR";  //TODO may depend on database type
     			//clean up nodes without classification  //this should not happen with correct "delete" implementation
     			String sql = String.format(" DELETE FROM %s WHERE %s IS NULL ", tableName, treeIdColumnName);
     			datasource.executeUpdate(sql);
     			//... set all index entries to NULL
     			sql = String.format(" UPDATE %s SET %s = NULL", tableName, indexColumnName);
     			datasource.executeUpdate(sql);
     			//start
     			String separator = ITreeNode.separator;
     			String treePrefix = ITreeNode.treePrefix;
     			sql = String.format(" UPDATE %s " +
     					" SET %s = CONCAT('%s%s', %s, '%s', id, '%s') " +
     					" WHERE %s IS NULL AND %s IS NOT NULL ",
     						tableName,
     						indexColumnName, separator, treePrefix, treeIdColumnName, separator, separator,
     					" WHERE %s IS NULL AND %s IS NOT NULL ",
     						tableName,
     						indexColumnName, separator, treePrefix, treeIdColumnName, separator, separator,
     						parentIdColumnName, treeIdColumnName);
     			datasource.executeUpdate(sql);
     			//width search index creation
     			String sqlCount = String.format(" SELECT count(*) as n " +
     					" FROM %s child INNER JOIN %s parent ON child.%s = parent.id " +
     					" WHERE parent.%s IS NOT NULL AND child.%s IS NULL ",
     					tableName, tableName, parentIdColumnName, indexColumnName, indexColumnName);
     			Long n;
     			do {
     				//MySQL
     				if (datasource.getDatabaseType().equals(DatabaseTypeEnum.MySQL)){
     					sql = String.format(" UPDATE %s child " +
     							" INNER JOIN %s parent ON child.%s = parent.id " +
     							" SET child.%s = CONCAT( parent.%s, child.id, '%s') " +
     							" WHERE parent.%s IS NOT NULL AND child.%s IS NULL ",
     								tableName,
     								tableName, parentIdColumnName,
     							" WHERE parent.%s IS NOT NULL AND child.%s IS NULL ",
     								tableName,
     								tableName, parentIdColumnName,
     								indexColumnName, indexColumnName, separator,
     								indexColumnName, indexColumnName);
     				}else{
     					//ANSI
     					//http://stackoverflow.com/questions/1293330/how-can-i-do-an-update-statement-with-join-in-sql
     					//does not work with MySQL as MySQL does not allow to use the same table in Subselect and Update (error 1093: http://dev.mysql.com/doc/refman/5.1/de/subquery-errors.html)
     					//does not work with MySQL as MySQL does not allow to use the same table in Subselect and Update (error 1093: http://dev.mysql.com/doc/refman/5.1/de/subquery-errors.html)
     					sql = String.format(" UPDATE %s " +
     							" SET %s = ( " +
     								" ( SELECT CONCAT ( parent.%s, %s.id, '%s') " +
     								" ( SELECT CONCAT ( parent.%s, %s.id, '%s') " +
     									" FROM %s parent " +
     									" WHERE parent.id = %s.%s ) " +
     								" ) " +
-...
     								indexColumnName, tableName, separator,
     								tableName,
     								tableName, parentIdColumnName,
     								tableName,
     								tableName, parentIdColumnName, indexColumnName, tableName, indexColumnName
     							);
+    				}
     				datasource.executeUpdate(sql);
     				n = (Long)datasource.getSingleValue(sqlCount);
     			}	while (n > 0) ;
     			sqlCount = String.format(" SELECT count(*) as n " +
     					" FROM %s " +
     					" WHERE %s IS NULL ", tableName, indexColumnName);
-...
     				String message = "There are tree nodes with no tree index in %s. This indicates that there is a problem in the tree structure of 1 or more classifications.";
     				logger.error(String.format(message, tableName));
+    			}
     			return result;
     		}catch(Exception e){
     			monitor.warning(e.getMessage(), e);

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
      */
     public class UniqueIndexDropper extends AuditedSchemaUpdaterStepBase<UniqueIndexDropper> implements ISchemaUpdaterStep {
     	private static final Logger logger = Logger.getLogger(UniqueIndexDropper.class);
     	private String indexColumn;
     	private final String indexColumn;
     	public static final UniqueIndexDropper NewInstance(String tableName, String indexColumn, boolean includeAudTable){
     		String stepName = "Drop index " + tableName + "-" + indexColumn;
     		return new UniqueIndexDropper(stepName, tableName, indexColumn, includeAudTable);
+    	}
     	protected UniqueIndexDropper(String stepName, String tableName, String indexColumn, boolean includeAudTable) {
     		super(stepName);
     		this.tableName = tableName;
     		super(stepName, tableName, includeAudTable);
     		this.indexColumn = indexColumn;
     		this.includeAudTable = includeAudTable;
+    	}
     	@Override
-...
     	private boolean checkExists(ICdmDataSource datasource) throws SQLException, DatabaseTypeNotSupportedException {
     		DatabaseTypeEnum type = datasource.getDatabaseType();
     		if (type.equals(DatabaseTypeEnum.MySQL)){
     			String sql = "SELECT count(*)	FROM information_schema.TABLE_CONSTRAINTS " +
     			String sql = "SELECT count(*)	FROM information_schema.TABLE_CONSTRAINTS " +
     					" WHERE table_name ='@tableName' AND CONSTRAINT_SCHEMA = '@dbName' AND CONSTRAINT_TYPE = 'UNIQUE' ";
     			sql = sql.replace("@tableName", tableName);
     			sql = sql.replace("@columnName", indexColumn);
-...
     		String updateQuery;
     		DatabaseTypeEnum type = datasource.getDatabaseType();
     		String indexName = getIndexName(datasource);
     //		if (type.equals(DatabaseTypeEnum.SqlServer2005)){
     			//MySQL allows both syntaxes
     //			updateQuery = "ALTER TABLE @tableName ADD @columnName @columnType";
-...
     			updateQuery = "ALTER TABLE @tableName DROP CONSTRAINT IF EXISTS @indexName";
     		}else if (type.equals(DatabaseTypeEnum.PostgreSQL)){
     //			updateQuery = "DROP INDEX IF EXISTS @indexName";  // does not work because index is used in the constraint
     //			updateQuery = "ALTER TABLE @tableName DROP CONSTRAINT IF EXISTS @indexName"; //"if exists" does not work (version 8.4)
     //			updateQuery = "ALTER TABLE @tableName DROP CONSTRAINT IF EXISTS @indexName"; //"if exists" does not work (version 8.4)
     			updateQuery = "ALTER TABLE @tableName DROP CONSTRAINT @indexName";
     		}else if (type.equals(DatabaseTypeEnum.MySQL)){
     			updateQuery = "ALTER TABLE @tableName DROP INDEX @indexName";
-...
+    		}
     		updateQuery = updateQuery.replace("@tableName", tableName);
     		updateQuery = updateQuery.replace("@indexName", indexName);
     		return updateQuery;
+    	}
-...
     		}else if (type.equals(DatabaseTypeEnum.MySQL)){
     			result = this.indexColumn;
     		}else if (type.equals(DatabaseTypeEnum.H2) ){
     //			String sql = "SELECT INDEX_NAME FROM INFORMATION_SCHEMA.INDEXES WHERE TABLE_NAME = @tableName AND INDEX_TYPE_NAME = 'UNIQUE INDEX'";
     			String sql = "SELECT CONSTRAINT_NAME " +
     //			String sql = "SELECT INDEX_NAME FROM INFORMATION_SCHEMA.INDEXES WHERE TABLE_NAME = @tableName AND INDEX_TYPE_NAME = 'UNIQUE INDEX'";
     			String sql = "SELECT CONSTRAINT_NAME " +
     					" FROM INFORMATION_SCHEMA.CONSTRAINTS "+
     					" WHERE CONSTRAINT_CATALOG = '@dbName' AND "+
     					" TABLE_NAME = '@tableName' AND CONSTRAINT_TYPE = 'UNIQUE' AND "+
     					" COLUMN_LIST = '@columnName'";
     					" TABLE_NAME = '@tableName' AND CONSTRAINT_TYPE = 'UNIQUE' AND "+
     					" COLUMN_LIST = '@columnName'";
     			sql = sql.replace("@tableName", tableName.toUpperCase());
     			sql = sql.replace("@columnName", indexColumn.toUpperCase());
     			sql = sql.replace("@dbName", datasource.getDatabase().toUpperCase());

Project

General

Profile

EDIT

Revision 7d7355ba

Added by Andreas Müller over 8 years ago