package org.apache.ddlutils; | |
/* | |
* 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.lang.reflect.Field; | |
import java.sql.Types; | |
import java.util.Arrays; | |
import java.util.HashMap; | |
import java.util.HashSet; | |
import java.util.Set; | |
import org.apache.commons.logging.Log; | |
import org.apache.commons.logging.LogFactory; | |
import org.apache.ddlutils.model.CascadeActionEnum; | |
/** | |
* Conatains information about the database platform such as supported features and native type mappings. | |
* | |
* @version $Revision: 289996 $ | |
*/ | |
public class PlatformInfo | |
{ | |
/** The Log to which logging calls will be made. */ | |
private final Log _log = LogFactory.getLog(PlatformInfo.class); | |
// properties influencing the definition of columns | |
/** Whether the database requires the explicit stating of NULL as the default value. */ | |
private boolean _nullAsDefaultValueRequired = false; | |
/** Whether default values can be defined for LONGVARCHAR/LONGVARBINARY columns. */ | |
private boolean _defaultValuesForLongTypesSupported = true; | |
// properties influencing the specification of table constraints | |
/** Whether primary key constraints are embedded inside the create table statement. */ | |
private boolean _primaryKeyEmbedded = true; | |
/** Whether primary key columns have to be required, too. */ | |
private boolean _primaryKeyColumnsHaveToBeRequired = false; | |
/** Whether mixed identity and non-identity columns in a primary key is supported. */ | |
private boolean _mixingIdentityAndNormalPrimaryKeyColumnsSupported = true; | |
/** Whether foreign key constraints are embedded inside the create table statement. */ | |
private boolean _foreignKeysEmbedded = false; | |
/** Whether embedded foreign key constraints are explicitly named. */ | |
private boolean _embeddedForeignKeysNamed = false; | |
/** Whether non-unique indices are supported. */ | |
private boolean _indicesSupported = true; | |
/** Whether indices are embedded inside the create table statement. */ | |
private boolean _indicesEmbedded = false; | |
/** Whether identity specification is supported for non-primary key columns. */ | |
private boolean _nonPrimaryKeyIdentityColumnsSupported = true; | |
/** Whether multiple identity columns in the same table are supported. */ | |
private boolean _multipleIdentityColumnsSupported = true; | |
/** Whether the auto-increment definition is done via the DEFAULT part of the column definition. */ | |
private boolean _defaultValueUsedForIdentitySpec = false; | |
// properties influencing the reading of models from live databases | |
/** Whether primary key columns are automatically required. */ | |
private boolean _primaryKeyColumnAutomaticallyRequired = false; | |
/** Whether identity columns are automatically required. */ | |
private boolean _identityColumnAutomaticallyRequired = false; | |
/** Whether system indices (database-generated indices for primary and foreign keys) are returned when | |
reading a model from a database. */ | |
private boolean _systemIndicesReturned = true; | |
/** Whether system indices for foreign keys are always non-unique or can be | |
unique (i.e. if a primary key column is used to establish the foreign key). */ | |
private boolean _systemForeignKeyIndicesAlwaysNonUnique = false; | |
/** Whether the database returns a synthetic default value for non-identity required columns. */ | |
private boolean _syntheticDefaultValueForRequiredReturned = false; | |
/** Whether the platform is able to determine auto increment status from an existing database. */ | |
private boolean _identityStatusReadingSupported = true; | |
// other DDL/DML properties | |
/** Whether comments are supported. */ | |
private boolean _sqlCommentsSupported = true; | |
/** Whether delimited identifiers are supported or not. */ | |
private boolean _delimitedIdentifiersSupported = true; | |
/** Whether an ALTER TABLE is needed to drop indexes. */ | |
private boolean _alterTableForDropUsed = false; | |
/** Whether the platform allows for the explicit specification of values for identity columns in INSERT | |
and UPDATE statements. */ | |
private boolean _identityOverrideAllowed = true; | |
/** Whether the values of identity columns can be read back from the database after insertion. */ | |
private boolean _lastIdentityValueReadable = true; | |
/** Whether auto-commit mode for the reading of the values of identity columns after insertion | |
shall be used. */ | |
private boolean _autoCommitModeForLastIdentityValueReading = true; | |
/** Specifies the maximum length that a table name can have for this database (-1 if there is no limit). */ | |
private int _maxTableNameLength = -1; | |
/** Specifies the maximum length that a column name can have for this database (-1 if there is no limit). */ | |
private int _maxColumnNameLength = -1; | |
/** Specifies the maximum length that a constraint name can have for this database (-1 if there is no limit). */ | |
private int _maxConstraintNameLength = -1; | |
/** Specifies the maximum length that a foreign key name can have for this database (-1 if there is no limit). */ | |
private int _maxForeignKeyNameLength = -1; | |
/** The string used for delimiting SQL identifiers, eg. table names, column names etc. */ | |
private String _delimiterToken = "\""; | |
/** The string used for escaping values when generating textual SQL statements. */ | |
private String _valueQuoteToken = "'"; | |
/** The string that starts a comment. */ | |
private String _commentPrefix = "--"; | |
/** The string that ends a comment. */ | |
private String _commentSuffix = ""; | |
/** The text separating individual sql commands. */ | |
private String _sqlCommandDelimiter = ";"; | |
/** Contains non-default mappings from jdbc to native types. */ | |
private HashMap _nativeTypes = new HashMap(); | |
/** Contains the jdbc types corresponding to the native types for non-default mappings. */ | |
private HashMap _targetJdbcTypes = new HashMap(); | |
/** Contains those JDBC types whose corresponding native types have a null value as the default value. */ | |
private HashSet _typesWithNullDefault = new HashSet(); | |
/** Contains those JDBC types whose corresponding native types are types that have a size on this platform. */ | |
private HashSet _typesWithSize = new HashSet(); | |
/** Contains the default sizes for those JDBC types whose corresponding native types require a size. */ | |
private HashMap _typesDefaultSizes = new HashMap(); | |
/** Contains those JDBC types whose corresponding native types are types that have precision and scale on this platform. */ | |
private HashSet _typesWithPrecisionAndScale = new HashSet(); | |
/** The default ON UPDATE action. */ | |
private CascadeActionEnum _defaultOnUpdateAction = CascadeActionEnum.NONE; | |
/** The default ON DELETE action. */ | |
private CascadeActionEnum _defaultOnDeleteAction = CascadeActionEnum.NONE; | |
/** Contains the supported ON UPDATE actions. */ | |
private HashSet _supportedOnUpdateActions = new HashSet(); | |
/** Contains the supported ON DELETE actions. */ | |
private HashSet _supportedOnDeleteActions = new HashSet(); | |
/** Contains for each ON UPDATE action the list of equivalent actions. */ | |
private HashMap _equivalentOnUpdateActions = new HashMap(); | |
/** Contains for each ON DELETE action the list of equivalent actions. */ | |
private HashMap _equivalentOnDeleteActions = new HashMap(); | |
/** | |
* Creates a new platform info object. | |
*/ | |
public PlatformInfo() | |
{ | |
_typesWithNullDefault.add(new Integer(Types.CHAR)); | |
_typesWithNullDefault.add(new Integer(Types.VARCHAR)); | |
_typesWithNullDefault.add(new Integer(Types.LONGVARCHAR)); | |
_typesWithNullDefault.add(new Integer(Types.CLOB)); | |
_typesWithNullDefault.add(new Integer(Types.BINARY)); | |
_typesWithNullDefault.add(new Integer(Types.VARBINARY)); | |
_typesWithNullDefault.add(new Integer(Types.LONGVARBINARY)); | |
_typesWithNullDefault.add(new Integer(Types.BLOB)); | |
_typesWithSize.add(new Integer(Types.CHAR)); | |
_typesWithSize.add(new Integer(Types.VARCHAR)); | |
_typesWithSize.add(new Integer(Types.BINARY)); | |
_typesWithSize.add(new Integer(Types.VARBINARY)); | |
_typesWithPrecisionAndScale.add(new Integer(Types.DECIMAL)); | |
_typesWithPrecisionAndScale.add(new Integer(Types.NUMERIC)); | |
_supportedOnUpdateActions.addAll(CascadeActionEnum.getEnumList()); | |
_supportedOnDeleteActions.addAll(CascadeActionEnum.getEnumList()); | |
} | |
// properties influencing the definition of columns | |
/** | |
* Determines whether a NULL needs to be explicitly stated when the column | |
* has no specified default value. Default is false. | |
* | |
* @return <code>true</code> if NULL must be written for empty default values | |
*/ | |
public boolean isNullAsDefaultValueRequired() | |
{ | |
return _nullAsDefaultValueRequired; | |
} | |
/** | |
* Specifies whether a NULL needs to be explicitly stated when the column | |
* has no specified default value. Default is false. | |
* | |
* @param requiresNullAsDefaultValue Whether NULL must be written for empty | |
* default values | |
*/ | |
public void setNullAsDefaultValueRequired(boolean requiresNullAsDefaultValue) | |
{ | |
_nullAsDefaultValueRequired = requiresNullAsDefaultValue; | |
} | |
/** | |
* Determines whether default values can be specified for LONGVARCHAR/LONGVARBINARY columns. | |
* | |
* @return <code>true</code> if default values are allowed | |
*/ | |
public boolean isDefaultValuesForLongTypesSupported() | |
{ | |
return _defaultValuesForLongTypesSupported; | |
} | |
/** | |
* Specifies whether default values can be specified for LONGVARCHAR/LONGVARBINARY columns. | |
* | |
* @param isSupported <code>true</code> if default values are supported | |
*/ | |
public void setDefaultValuesForLongTypesSupported(boolean isSupported) | |
{ | |
_defaultValuesForLongTypesSupported = isSupported; | |
} | |
// properties influencing the specification of table constraints | |
/** | |
* Determines whether primary key constraints are embedded in the create | |
* table clause or as seperate alter table statements. The default is | |
* embedded pks. | |
* | |
* @return <code>true</code> if pk constraints are embedded | |
*/ | |
public boolean isPrimaryKeyEmbedded() | |
{ | |
return _primaryKeyEmbedded; | |
} | |
/** | |
* Specifies whether the primary key constraints are embedded in the create | |
* table clause or as seperate alter table statements. | |
* | |
* @param primaryKeyEmbedded Whether pk constraints are embedded | |
*/ | |
public void setPrimaryKeyEmbedded(boolean primaryKeyEmbedded) | |
{ | |
_primaryKeyEmbedded = primaryKeyEmbedded; | |
} | |
/** | |
* Determines whether the primary key constraints have to be required, as well. | |
* | |
* @return <code>true</code> if pk constraints have to be required | |
*/ | |
public boolean isPrimaryKeyColumnsHaveToBeRequired() | |
{ | |
return _primaryKeyColumnsHaveToBeRequired; | |
} | |
/** | |
* Specifies whether the primary key constraints have to be required, as well. | |
* | |
* @param primaryKeyColumnsHaveToBeRequired Whether pk constraints need to be required | |
*/ | |
public void setPrimaryKeyColumnsHaveToBeRequired(boolean primaryKeyColumnsHaveToBeRequired) | |
{ | |
_primaryKeyColumnsHaveToBeRequired = primaryKeyColumnsHaveToBeRequired; | |
} | |
/** | |
* Determines whether primary key can contain identity and non-identity columns at the same time. | |
* | |
* @return <code>true</code> if idenity and non-identity columns can be mixed in the pk | |
*/ | |
public boolean isMixingIdentityAndNormalPrimaryKeyColumnsSupported() | |
{ | |
return _mixingIdentityAndNormalPrimaryKeyColumnsSupported; | |
} | |
/** | |
* Specifies whether primary key can contain identity and non-identity columns at the same time. | |
* | |
* @param mixingIdentityAndNormalPrimaryKeyColumnsSupported Whether idenity and non-identity columns | |
* can be mixed in the pk | |
*/ | |
public void setMixingIdentityAndNormalPrimaryKeyColumnsSupported(boolean mixingIdentityAndNormalPrimaryKeyColumnsSupported) | |
{ | |
_mixingIdentityAndNormalPrimaryKeyColumnsSupported = mixingIdentityAndNormalPrimaryKeyColumnsSupported; | |
} | |
/** | |
* Determines whether foreign key constraints are embedded in the create | |
* table clause or as seperate alter table statements. Per default, | |
* foreign keys are external. | |
* | |
* @return <code>true</code> if fk constraints are embedded | |
*/ | |
public boolean isForeignKeysEmbedded() | |
{ | |
return _foreignKeysEmbedded; | |
} | |
/** | |
* Specifies whether foreign key constraints are embedded in the create | |
* table clause or as seperate alter table statements. | |
* | |
* @param foreignKeysEmbedded Whether fk constraints are embedded | |
*/ | |
public void setForeignKeysEmbedded(boolean foreignKeysEmbedded) | |
{ | |
_foreignKeysEmbedded = foreignKeysEmbedded; | |
} | |
/** | |
* Returns whether embedded foreign key constraints should have a name. | |
* | |
* @return <code>true</code> if embedded fks have name | |
*/ | |
public boolean isEmbeddedForeignKeysNamed() | |
{ | |
return _embeddedForeignKeysNamed; | |
} | |
/** | |
* Specifies whether embedded foreign key constraints should be named. | |
* | |
* @param embeddedForeignKeysNamed Whether embedded fks shall have a name | |
*/ | |
public void setEmbeddedForeignKeysNamed(boolean embeddedForeignKeysNamed) | |
{ | |
_embeddedForeignKeysNamed = embeddedForeignKeysNamed; | |
} | |
/** | |
* Determines whether indices are supported. | |
* | |
* @return <code>true</code> if indices are supported | |
*/ | |
public boolean isIndicesSupported() | |
{ | |
return _indicesSupported; | |
} | |
/** | |
* Specifies whether indices are supported. | |
* | |
* @param supportingIndices <code>true</code> if indices are supported | |
*/ | |
public void setIndicesSupported(boolean supportingIndices) | |
{ | |
_indicesSupported = supportingIndices; | |
} | |
/** | |
* Determines whether the indices are embedded in the create table clause | |
* or as seperate statements. Per default, indices are external. | |
* | |
* @return <code>true</code> if indices are embedded | |
*/ | |
public boolean isIndicesEmbedded() | |
{ | |
return _indicesEmbedded; | |
} | |
/** | |
* Specifies whether indices are embedded in the create table clause or | |
* as seperate alter table statements. | |
* | |
* @param indicesEmbedded Whether indices are embedded | |
*/ | |
public void setIndicesEmbedded(boolean indicesEmbedded) | |
{ | |
_indicesEmbedded = indicesEmbedded; | |
} | |
/** | |
* Determines whether non-primary key columns can be auto-incrementing (IDENTITY columns). | |
* | |
* @return <code>true</code> if normal non-PK columns can be auto-incrementing | |
*/ | |
public boolean isNonPrimaryKeyIdentityColumnsSupported() | |
{ | |
return _nonPrimaryKeyIdentityColumnsSupported; | |
} | |
/** | |
* Specifies whether non-primary key columns can be auto-incrementing (IDENTITY columns). | |
* | |
* @param supportingNonPKIdentityColumns <code>true</code> if normal non-PK columns can | |
* be auto-incrementing | |
*/ | |
public void setNonPrimaryKeyIdentityColumnsSupported(boolean supportingNonPKIdentityColumns) | |
{ | |
_nonPrimaryKeyIdentityColumnsSupported = supportingNonPKIdentityColumns; | |
} | |
/** | |
* Determines whether multiple columns in the same table can be auto-incrementing (IDENTITY columns). | |
* | |
* @return <code>true</code> if multiple columns can be auto-incrementing in the same table | |
*/ | |
public boolean isMultipleIdentityColumnsSupported() | |
{ | |
return _multipleIdentityColumnsSupported; | |
} | |
/** | |
* Specifies whether multiple columns in the same table can be auto-incrementing (IDENTITY columns). | |
* | |
* @param supportingMultipleIdentityColumns <code>true</code> if multiple columns can be auto-incrementing | |
* in the same table | |
*/ | |
public void setMultipleIdentityColumnsSupported(boolean supportingMultipleIdentityColumns) | |
{ | |
_multipleIdentityColumnsSupported = supportingMultipleIdentityColumns; | |
} | |
/** | |
* Determines whether the auto-increment specification uses the DEFAULT value of the | |
* column definition. | |
* | |
* @return <code>true</code> if the auto-increment spec is done via the DEFAULT value | |
*/ | |
public boolean isDefaultValueUsedForIdentitySpec() | |
{ | |
return _defaultValueUsedForIdentitySpec; | |
} | |
/** | |
* Specifies whether the auto-increment specification uses the DEFAULT value of the | |
* column definition. | |
* | |
* @param identitySpecUsesDefaultValue <code>true</code> if the auto-increment spec is | |
* done via the DEFAULT value | |
*/ | |
public void setDefaultValueUsedForIdentitySpec(boolean identitySpecUsesDefaultValue) | |
{ | |
_defaultValueUsedForIdentitySpec = identitySpecUsesDefaultValue; | |
} | |
// properties influencing the reading of models from live databases | |
/** | |
* Determines whether the database will make a primary key column automatically required. | |
* | |
* @return <code>true</code> if primary key columns are automatically required | |
*/ | |
public boolean isPrimaryKeyColumnAutomaticallyRequired() | |
{ | |
return _primaryKeyColumnAutomaticallyRequired; | |
} | |
/** | |
* Specifies whether the database will make a primary key column automatically required. | |
* | |
* @param primaryKeyAutomaticallyRequired <code>true</code> if primary key columns are | |
* automatically required | |
*/ | |
public void setPrimaryKeyColumnAutomaticallyRequired(boolean primaryKeyAutomaticallyRequired) | |
{ | |
_primaryKeyColumnAutomaticallyRequired = primaryKeyAutomaticallyRequired; | |
} | |
/** | |
* Determines whether the database will make an idenity column automatically required. | |
* | |
* @return <code>true</code> if identity columns are automatically required | |
*/ | |
public boolean isIdentityColumnAutomaticallyRequired() | |
{ | |
return _identityColumnAutomaticallyRequired; | |
} | |
/** | |
* Specifies whether the database will make a primary key column automatically required. | |
* | |
* @param identityAutomaticallyRequired <code>true</code> if identity columns are | |
* automatically required | |
*/ | |
public void setIdentityColumnAutomaticallyRequired(boolean identityAutomaticallyRequired) | |
{ | |
_identityColumnAutomaticallyRequired = identityAutomaticallyRequired; | |
} | |
/** | |
* Determines whether database-generated indices for primary and foreign keys are | |
* returned when reading a model from a database. | |
* | |
* @return <code>true</code> if system indices are read from a live database | |
*/ | |
public boolean isSystemIndicesReturned() | |
{ | |
return _systemIndicesReturned; | |
} | |
/** | |
* Specifies whether database-generated indices for primary and foreign keys are | |
* returned when reading a model from a database. | |
* | |
* @param returningSystemIndices <code>true</code> if system indices are read from | |
* a live database | |
*/ | |
public void setSystemIndicesReturned(boolean returningSystemIndices) | |
{ | |
_systemIndicesReturned = returningSystemIndices; | |
} | |
/** | |
* Determines whether system indices for foreign keys are always non-unique or can be | |
* unique (i.e. if a primary key column is used to establish the foreign key). | |
* | |
* @return <code>true</code> if system foreign key indices are always non-unique; | |
* default is <code>false</code> | |
*/ | |
public boolean isSystemForeignKeyIndicesAlwaysNonUnique() | |
{ | |
return _systemForeignKeyIndicesAlwaysNonUnique; | |
} | |
/** | |
* Specifies whether system indices for foreign keys are always non-unique or can be | |
* unique (i.e. if a primary key column is used to establish the foreign key). | |
* | |
* @param alwaysNonUnique <code>true</code> if system foreign key indices are always | |
* non-unique | |
*/ | |
public void setSystemForeignKeyIndicesAlwaysNonUnique(boolean alwaysNonUnique) | |
{ | |
_systemForeignKeyIndicesAlwaysNonUnique = alwaysNonUnique; | |
} | |
/** | |
* Determines whether the platform returns synthetic default values (e.g. 0 for numeric | |
* columns etc.) for non-identity required columns when reading a model from a database. | |
* | |
* @return <code>true</code> if synthetic default values are returned for non-identity | |
* required columns | |
*/ | |
public boolean isSyntheticDefaultValueForRequiredReturned() | |
{ | |
return _syntheticDefaultValueForRequiredReturned; | |
} | |
/** | |
* Specifies whether the platform returns synthetic default values (e.g. 0 for numeric | |
* columns etc.) for non-identity required columns when reading a model from a database. | |
* | |
* @param returningDefaultValue <code>true</code> if synthetic default values are returned for | |
* non-identity required columns | |
*/ | |
public void setSyntheticDefaultValueForRequiredReturned(boolean returningDefaultValue) | |
{ | |
_syntheticDefaultValueForRequiredReturned = returningDefaultValue; | |
} | |
/** | |
* Determines whether the platform is able to read the auto-increment status for columns | |
* from an existing database. | |
* | |
* @return <code>true</code> if the auto-increment status can be determined from an existing | |
* database | |
*/ | |
public boolean getIdentityStatusReadingSupported() | |
{ | |
return _identityStatusReadingSupported; | |
} | |
/** | |
* Specifies whether the platform is able to read the auto-increment status for columns | |
* from an existing database. | |
* | |
* @param canReadAutoIncrementStatus <code>true</code> if the auto-increment status can be | |
* determined from an existing database | |
*/ | |
public void setIdentityStatusReadingSupported(boolean canReadAutoIncrementStatus) | |
{ | |
_identityStatusReadingSupported = canReadAutoIncrementStatus; | |
} | |
// other ddl properties | |
/** | |
* Determines whether the database supports SQL comments. | |
* | |
* @return <code>true</code> if comments are supported | |
*/ | |
public boolean isSqlCommentsSupported() | |
{ | |
return _sqlCommentsSupported; | |
} | |
/** | |
* Specifies whether SQL comments are supported by the database. | |
* | |
* @param commentsSupported <code>true</code> if comments are supported | |
*/ | |
public void setSqlCommentsSupported(boolean commentsSupported) | |
{ | |
_sqlCommentsSupported = commentsSupported; | |
} | |
/** | |
* Determines whether delimited identifiers are supported. | |
* | |
* @return <code>true</code> if delimited identifiers are supported | |
*/ | |
public boolean isDelimitedIdentifiersSupported() | |
{ | |
return _delimitedIdentifiersSupported; | |
} | |
/** | |
* Specifies whether delimited identifiers are supported. | |
* | |
* @param areSupported <code>true</code> if delimited identifiers are supported | |
*/ | |
public void setDelimitedIdentifiersSupported(boolean areSupported) | |
{ | |
_delimitedIdentifiersSupported = areSupported; | |
} | |
/** | |
* Determines whether an ALTER TABLE statement shall be used for dropping indices | |
* or constraints. The default is false. | |
* | |
* @return <code>true</code> if ALTER TABLE is required | |
*/ | |
public boolean isAlterTableForDropUsed() | |
{ | |
return _alterTableForDropUsed; | |
} | |
/** | |
* Specifies whether an ALTER TABLE statement shall be used for dropping indices | |
* or constraints. | |
* | |
* @param useAlterTableForDrop Whether ALTER TABLE will be used | |
*/ | |
public void setAlterTableForDropUsed(boolean useAlterTableForDrop) | |
{ | |
_alterTableForDropUsed = useAlterTableForDrop; | |
} | |
/** | |
* Determines whether the platform is allows the explicit specification of values for | |
* identity columns in INSERT/UPDATE statements. | |
* | |
* @return <code>true</code> if values for identity columns can be specified | |
*/ | |
public boolean isIdentityOverrideAllowed() | |
{ | |
return _identityOverrideAllowed; | |
} | |
/** | |
* Specifies whether the platform is allows the explicit specification of values for | |
* identity columns in INSERT/UPDATE statements. | |
* | |
* @param identityOverrideAllowed <code>true</code> if values for identity columns can be specified | |
*/ | |
public void setIdentityOverrideAllowed(boolean identityOverrideAllowed) | |
{ | |
_identityOverrideAllowed = identityOverrideAllowed; | |
} | |
/** | |
* Determines whether the values of identity columns can be read back from the | |
* database after insertion of a row. | |
* | |
* @return <code>true</code> if the identity column(s) can be read back | |
*/ | |
public boolean isLastIdentityValueReadable() | |
{ | |
return _lastIdentityValueReadable; | |
} | |
/** | |
* Specifies whether the values of identity columns can be read back from the | |
* database after insertion of a row. | |
* | |
* @param lastIdentityValueReadable <code>true</code> if the identity column(s) can be read back | |
*/ | |
public void setLastIdentityValueReadable(boolean lastIdentityValueReadable) | |
{ | |
_lastIdentityValueReadable = lastIdentityValueReadable; | |
} | |
/** | |
* Determines whether auto-commit mode for the reading of the values of identity columns | |
* after insertion shall be used, i.e. whether between the insertion of the row and the | |
* reading of the database-generated identity value a commit is issued. | |
* | |
* @return <code>true</code> if auto-commit mode is used | |
*/ | |
public boolean isAutoCommitModeForLastIdentityValueReading() | |
{ | |
return _autoCommitModeForLastIdentityValueReading; | |
} | |
/** | |
* Determines whether auto-commit mode for the reading of the values of identity columns | |
* after insertion shall be used, i.e. whether between the insertion of the row and the | |
* reading of the database-generated identity value a commit is issued. | |
* | |
* @param autoCommitModeForLastIdentityValueReading <code>true</code> if auto-commit mode | |
* shall be used | |
*/ | |
public void setAutoCommitModeForLastIdentityValueReading(boolean autoCommitModeForLastIdentityValueReading) | |
{ | |
_autoCommitModeForLastIdentityValueReading = autoCommitModeForLastIdentityValueReading; | |
} | |
/** | |
* Returns the maximum number of characters that a table name can have. | |
* | |
* @return The number of characters, or -1 if not limited | |
*/ | |
public int getMaxTableNameLength() | |
{ | |
return _maxTableNameLength; | |
} | |
/** | |
* Returns the maximum number of characters that a column name can have. | |
* | |
* @return The number of characters, or -1 if not limited | |
*/ | |
public int getMaxColumnNameLength() | |
{ | |
return _maxColumnNameLength; | |
} | |
/** | |
* Returns the maximum number of characters that a constraint name can have. | |
* | |
* @return The number of characters, or -1 if not limited | |
*/ | |
public int getMaxConstraintNameLength() | |
{ | |
return _maxConstraintNameLength; | |
} | |
/** | |
* Returns the maximum number of characters that a foreign key name can have. | |
* | |
* @return The number of characters, or -1 if not limited | |
*/ | |
public int getMaxForeignKeyNameLength() | |
{ | |
return _maxForeignKeyNameLength; | |
} | |
/** | |
* Sets the maximum length of all identifiers that this database allows. | |
* Use this method if the length limit is the same for all kinds of identifiers. | |
* | |
* @param maxIdentifierLength The maximum identifier length, -1 if unlimited | |
*/ | |
public void setMaxIdentifierLength(int maxIdentifierLength) | |
{ | |
_maxTableNameLength = maxIdentifierLength; | |
_maxColumnNameLength = maxIdentifierLength; | |
_maxConstraintNameLength = maxIdentifierLength; | |
_maxForeignKeyNameLength = maxIdentifierLength; | |
} | |
/** | |
* Sets the maximum length of table names that this database allows. | |
* | |
* @param maxTableNameLength The maximum length, -1 if unlimited | |
*/ | |
public void setMaxTableNameLength(int maxTableNameLength) | |
{ | |
_maxTableNameLength = maxTableNameLength; | |
} | |
/** | |
* Sets the maximum length of column names that this database allows. | |
* | |
* @param maxColumnNameLength The maximum length, -1 if unlimited | |
*/ | |
public void setMaxColumnNameLength(int maxColumnNameLength) | |
{ | |
_maxColumnNameLength = maxColumnNameLength; | |
} | |
/** | |
* Sets the maximum length of constraint names that this database allows. | |
* | |
* @param maxConstraintNameLength The maximum length, -1 if unlimited | |
*/ | |
public void setMaxConstraintNameLength(int maxConstraintNameLength) | |
{ | |
_maxConstraintNameLength = maxConstraintNameLength; | |
} | |
/** | |
* Sets the maximum length of foreign key names that this database allows. | |
* | |
* @param maxForeignKeyNameLength The maximum length, -1 if unlimited | |
*/ | |
public void setMaxForeignKeyNameLength(int maxForeignKeyNameLength) | |
{ | |
_maxForeignKeyNameLength = maxForeignKeyNameLength; | |
} | |
/** | |
* Returns the text that is used to delimit identifiers (eg. table names). | |
* Per default, this is a double quotation character ("). | |
* | |
* @return The delimiter text | |
*/ | |
public String getDelimiterToken() | |
{ | |
return _delimiterToken; | |
} | |
/** | |
* Sets the text that is used to delimit identifiers (eg. table names). | |
* | |
* @param delimiterToken The delimiter text | |
*/ | |
public void setDelimiterToken(String delimiterToken) | |
{ | |
_delimiterToken = delimiterToken; | |
} | |
/** | |
* Returns the text that is used for for quoting values (e.g. text) when | |
* printing default values and in generates insert/update/delete statements. | |
* Per default, this is a single quotation character ('). | |
* | |
* @return The quote text | |
*/ | |
public String getValueQuoteToken() | |
{ | |
return _valueQuoteToken; | |
} | |
/** | |
* Sets the text that is used for for quoting values (e.g. text) when | |
* printing default values and in generates insert/update/delete statements. | |
* | |
* @param valueQuoteChar The new quote text | |
*/ | |
public void setValueQuoteToken(String valueQuoteChar) | |
{ | |
_valueQuoteToken = valueQuoteChar; | |
} | |
/** | |
* Returns the string that denotes the beginning of a comment. | |
* | |
* @return The comment prefix | |
*/ | |
public String getCommentPrefix() | |
{ | |
return _commentPrefix; | |
} | |
/** | |
* Sets the text that starts a comment. | |
* | |
* @param commentPrefix The new comment prefix | |
*/ | |
public void setCommentPrefix(String commentPrefix) | |
{ | |
_commentPrefix = (commentPrefix == null ? "" : commentPrefix); | |
} | |
/** | |
* Returns the string that denotes the end of a comment. Note that comments will | |
* be always on their own line. | |
* | |
* @return The comment suffix | |
*/ | |
public String getCommentSuffix() | |
{ | |
return _commentSuffix; | |
} | |
/** | |
* Sets the text that ends a comment. | |
* | |
* @param commentSuffix The new comment suffix | |
*/ | |
public void setCommentSuffix(String commentSuffix) | |
{ | |
_commentSuffix = (commentSuffix == null ? "" : commentSuffix); | |
} | |
/** | |
* Returns the text separating individual sql commands. | |
* | |
* @return The delimiter text | |
*/ | |
public String getSqlCommandDelimiter() | |
{ | |
return _sqlCommandDelimiter; | |
} | |
/** | |
* Sets the text separating individual sql commands. | |
* | |
* @param sqlCommandDelimiter The delimiter text | |
*/ | |
public void setSqlCommandDelimiter(String sqlCommandDelimiter) | |
{ | |
_sqlCommandDelimiter = sqlCommandDelimiter; | |
} | |
/** | |
* Returns the database-native type for the given type code. | |
* | |
* @param typeCode The {@link java.sql.Types} type code | |
* @return The native type or <code>null</code> if there isn't one defined | |
*/ | |
public String getNativeType(int typeCode) | |
{ | |
return (String)_nativeTypes.get(new Integer(typeCode)); | |
} | |
/** | |
* Returns the jdbc type corresponding to the native type that is used for the given | |
* jdbc type. This is most often the same jdbc type, but can also be a different one. | |
* For instance, if a database has no native boolean type, then the source jdbc type | |
* would be <code>BIT</code> or <code>BOOLEAN</code>, and the target jdbc type might | |
* be <code>TINYINT</code> or <code>SMALLINT</code>. | |
* | |
* @param typeCode The {@link java.sql.Types} type code | |
* @return The target jdbc type | |
*/ | |
public int getTargetJdbcType(int typeCode) | |
{ | |
Integer targetJdbcType = (Integer)_targetJdbcTypes.get(new Integer(typeCode)); | |
return targetJdbcType == null ? typeCode : targetJdbcType.intValue(); | |
} | |
/** | |
* Adds a mapping from jdbc type to database-native type. | |
* | |
* @param jdbcTypeCode The jdbc type code as defined by {@link java.sql.Types} | |
* @param nativeType The native type | |
*/ | |
public void addNativeTypeMapping(int jdbcTypeCode, String nativeType) | |
{ | |
_nativeTypes.put(new Integer(jdbcTypeCode), nativeType); | |
} | |
/** | |
* Adds a mapping from jdbc type to database-native type. | |
* | |
* @param jdbcTypeCode The jdbc type code as defined by {@link java.sql.Types} | |
* @param nativeType The native type | |
* @param targetJdbcTypeCode The jdbc type code corresponding to the native type | |
* (e.g. when reading the model from the database) | |
*/ | |
public void addNativeTypeMapping(int jdbcTypeCode, String nativeType, int targetJdbcTypeCode) | |
{ | |
addNativeTypeMapping(jdbcTypeCode, nativeType); | |
_targetJdbcTypes.put(new Integer(jdbcTypeCode), new Integer(targetJdbcTypeCode)); | |
} | |
/** | |
* Adds a mapping from jdbc type to database-native type. Note that this | |
* method accesses the named constant in {@link java.sql.Types} via reflection | |
* and is thus safe to use under JDK 1.2/1.3 even with constants defined | |
* only in later Java versions - for these, the method simply will not add | |
* a mapping. | |
* | |
* @param jdbcTypeName The jdbc type name, one of the constants defined in | |
* {@link java.sql.Types} | |
* @param nativeType The native type | |
*/ | |
public void addNativeTypeMapping(String jdbcTypeName, String nativeType) | |
{ | |
try | |
{ | |
Field constant = Types.class.getField(jdbcTypeName); | |
if (constant != null) | |
{ | |
addNativeTypeMapping(constant.getInt(null), nativeType); | |
} | |
} | |
catch (Exception ex) | |
{ | |
// ignore -> won't be defined | |
_log.warn("Cannot add native type mapping for undefined jdbc type "+jdbcTypeName, ex); | |
} | |
} | |
/** | |
* Adds a mapping from jdbc type to database-native type. Note that this | |
* method accesses the named constant in {@link java.sql.Types} via reflection | |
* and is thus safe to use under JDK 1.2/1.3 even with constants defined | |
* only in later Java versions - for these, the method simply will not add | |
* a mapping. | |
* | |
* @param jdbcTypeName The jdbc type name, one of the constants defined | |
* in {@link java.sql.Types} | |
* @param nativeType The native type | |
* @param targetJdbcTypeName The jdbc type corresponding to the native type | |
* (e.g. when reading the model from the database) | |
*/ | |
public void addNativeTypeMapping(String jdbcTypeName, String nativeType, String targetJdbcTypeName) | |
{ | |
try | |
{ | |
Field sourceType = Types.class.getField(jdbcTypeName); | |
Field targetType = Types.class.getField(targetJdbcTypeName); | |
if ((sourceType != null) && (targetType != null)) | |
{ | |
addNativeTypeMapping(sourceType.getInt(null), nativeType, targetType.getInt(null)); | |
} | |
} | |
catch (Exception ex) | |
{ | |
// ignore -> won't be defined | |
_log.warn("Cannot add native type mapping for undefined jdbc type "+jdbcTypeName+", target jdbc type "+targetJdbcTypeName, ex); | |
} | |
} | |
/** | |
* Determines whether the native type for the given sql type code (one of the | |
* {@link java.sql.Types} constants) has a null default value on this platform. | |
* | |
* @param sqlTypeCode The sql type code | |
* @return <code>true</code> if the native type has a null default value | |
*/ | |
public boolean hasNullDefault(int sqlTypeCode) | |
{ | |
return _typesWithNullDefault.contains(new Integer(sqlTypeCode)); | |
} | |
/** | |
* Specifies whether the native type for the given sql type code (one of the | |
* {@link java.sql.Types} constants) has a null default value on this platform. | |
* | |
* @param sqlTypeCode The sql type code | |
* @param hasNullDefault <code>true</code> if the native type has a null default value | |
*/ | |
public void setHasNullDefault(int sqlTypeCode, boolean hasNullDefault) | |
{ | |
if (hasNullDefault) | |
{ | |
_typesWithNullDefault.add(new Integer(sqlTypeCode)); | |
} | |
else | |
{ | |
_typesWithNullDefault.remove(new Integer(sqlTypeCode)); | |
} | |
} | |
/** | |
* Determines whether the native type for the given sql type code (one of the | |
* {@link java.sql.Types} constants) has a size specification on this platform. | |
* | |
* @param sqlTypeCode The sql type code | |
* @return <code>true</code> if the native type has a size specification | |
*/ | |
public boolean hasSize(int sqlTypeCode) | |
{ | |
return _typesWithSize.contains(new Integer(sqlTypeCode)); | |
} | |
/** | |
* Specifies whether the native type for the given sql type code (one of the | |
* {@link java.sql.Types} constants) has a size specification on this platform. | |
* | |
* @param sqlTypeCode The sql type code | |
* @param hasSize <code>true</code> if the native type has a size specification | |
*/ | |
public void setHasSize(int sqlTypeCode, boolean hasSize) | |
{ | |
if (hasSize) | |
{ | |
_typesWithSize.add(new Integer(sqlTypeCode)); | |
} | |
else | |
{ | |
_typesWithSize.remove(new Integer(sqlTypeCode)); | |
} | |
} | |
/** | |
* Returns the default size value for the given type, if any. | |
* | |
* @param jdbcTypeCode The jdbc type code | |
* @return The default size or <code>null</code> if none is defined | |
*/ | |
public Integer getDefaultSize(int jdbcTypeCode) | |
{ | |
return (Integer)_typesDefaultSizes.get(new Integer(jdbcTypeCode)); | |
} | |
/** | |
* Adds a default size for the given jdbc type. | |
* | |
* @param jdbcTypeCode The jdbc type code | |
* @param defaultSize The default size | |
*/ | |
public void setDefaultSize(int jdbcTypeCode, int defaultSize) | |
{ | |
_typesDefaultSizes.put(new Integer(jdbcTypeCode), new Integer(defaultSize)); | |
} | |
/** | |
* Adds a default size for the given jdbc type. | |
* | |
* @param jdbcTypeName The name of the jdbc type, one of the {@link Types} constants | |
* @param defaultSize The default size | |
*/ | |
public void setDefaultSize(String jdbcTypeName, int defaultSize) | |
{ | |
try | |
{ | |
Field constant = Types.class.getField(jdbcTypeName); | |
if (constant != null) | |
{ | |
setDefaultSize(constant.getInt(null), defaultSize); | |
} | |
} | |
catch (Exception ex) | |
{ | |
// ignore -> won't be defined | |
_log.warn("Cannot add default size for undefined jdbc type "+jdbcTypeName, ex); | |
} | |
} | |
/** | |
* Determines whether the native type for the given sql type code (one of the | |
* {@link java.sql.Types} constants) has precision and scale specifications on | |
* this platform. | |
* | |
* @param sqlTypeCode The sql type code | |
* @return <code>true</code> if the native type has precision and scale specifications | |
*/ | |
public boolean hasPrecisionAndScale(int sqlTypeCode) | |
{ | |
return _typesWithPrecisionAndScale.contains(new Integer(sqlTypeCode)); | |
} | |
/** | |
* Specifies whether the native type for the given sql type code (one of the | |
* {@link java.sql.Types} constants) has precision and scale specifications on | |
* this platform. | |
* | |
* @param sqlTypeCode The sql type code | |
* @param hasPrecisionAndScale <code>true</code> if the native type has precision and scale specifications | |
*/ | |
public void setHasPrecisionAndScale(int sqlTypeCode, boolean hasPrecisionAndScale) | |
{ | |
if (hasPrecisionAndScale) | |
{ | |
_typesWithPrecisionAndScale.add(new Integer(sqlTypeCode)); | |
} | |
else | |
{ | |
_typesWithPrecisionAndScale.remove(new Integer(sqlTypeCode)); | |
} | |
} | |
/** | |
* Sets the actions that this platform supports for ON UPDATE. | |
* | |
* @param actions The actions | |
*/ | |
public void setSupportedOnUpdateActions(CascadeActionEnum[] actions) | |
{ | |
_supportedOnUpdateActions.clear(); | |
_supportedOnUpdateActions.addAll(Arrays.asList(actions)); | |
} | |
/** | |
* Determines whether the given action is supported for ON UPDATE on this platform. | |
* | |
* @param action The action | |
* @return <code>true</code> if the action is supported | |
*/ | |
public boolean isActionSupportedForOnUpdate(CascadeActionEnum action) | |
{ | |
return _supportedOnUpdateActions.contains(action); | |
} | |
/** | |
* Sets the actions that this platform supports for ON DELETE. | |
* | |
* @param actions The actions | |
*/ | |
public void setSupportedOnDeleteActions(CascadeActionEnum[] actions) | |
{ | |
_supportedOnDeleteActions.clear(); | |
_supportedOnDeleteActions.addAll(Arrays.asList(actions)); | |
} | |
/** | |
* Determines whether the given action is supported for ON DELETE on this platform. | |
* | |
* @param action The action | |
* @return <code>true</code> if the action is supported | |
*/ | |
public boolean isActionSupportedForOnDelete(CascadeActionEnum action) | |
{ | |
return _supportedOnDeleteActions.contains(action); | |
} | |
/** | |
* Returns the default ON UPDATE action that is used if none is specified. | |
* | |
* @return The default action | |
*/ | |
public CascadeActionEnum getDefaultOnUpdateAction() | |
{ | |
return _defaultOnUpdateAction; | |
} | |
/** | |
* Sets the default ON UPDATE action that is used if none is specified. | |
* | |
* @param defaultOnUpdateAction The default action | |
*/ | |
public void setDefaultOnUpdateAction(CascadeActionEnum defaultOnUpdateAction) | |
{ | |
_defaultOnUpdateAction = defaultOnUpdateAction; | |
} | |
/** | |
* Returns the default ON DELETE action that is used if none is specified. | |
* | |
* @return The default action | |
*/ | |
public CascadeActionEnum getDefaultOnDeleteAction() | |
{ | |
return _defaultOnDeleteAction; | |
} | |
/** | |
* Sets the default ON DELETE action that is used if none is specified. | |
* | |
* @param defaultOnDeleteAction The default action | |
*/ | |
public void setDefaultOnDeleteAction(CascadeActionEnum defaultOnDeleteAction) | |
{ | |
_defaultOnDeleteAction = defaultOnDeleteAction; | |
} | |
/** | |
* Registers the given pair of ON UPDATE actions to be equivalent. Equivalent actions will not | |
* cause a foreign key to be changed/recreated when altering a database. | |
* | |
* @param actionA The first action | |
* @param actionB The second action | |
*/ | |
public void addEquivalentOnUpdateActions(CascadeActionEnum actionA, CascadeActionEnum actionB) | |
{ | |
if (!actionA.equals(actionB)) | |
{ | |
Set actionsEquivalentToActionA = (Set)_equivalentOnUpdateActions.get(actionA); | |
Set actionsEquivalentToActionB = (Set)_equivalentOnUpdateActions.get(actionB); | |
if (actionsEquivalentToActionA == null) | |
{ | |
actionsEquivalentToActionA = new HashSet(); | |
_equivalentOnUpdateActions.put(actionA, actionsEquivalentToActionA); | |
} | |
if (actionsEquivalentToActionB == null) | |
{ | |
actionsEquivalentToActionB = new HashSet(); | |
_equivalentOnUpdateActions.put(actionB, actionsEquivalentToActionB); | |
} | |
actionsEquivalentToActionA.add(actionB); | |
actionsEquivalentToActionB.add(actionA); | |
} | |
} | |
/** | |
* Determiones whether the two ON UPDATE actions are equivalent. Equivalent actions will not | |
* cause a foreign key to be changed/recreated when altering a database. | |
* | |
* @param actionA The first action | |
* @param actionB The second action | |
* @return <code>true</code> if the two actions are equivalent | |
*/ | |
public boolean areEquivalentOnUpdateActions(CascadeActionEnum actionA, CascadeActionEnum actionB) | |
{ | |
Set actionsEquivalentToActionA = (Set)_equivalentOnUpdateActions.get(actionA); | |
return actionsEquivalentToActionA == null ? false : actionsEquivalentToActionA.contains(actionB); | |
} | |
/** | |
* Registers the given pair of ON DELETE actions to be equivalent. Equivalent actions will not | |
* cause a foreign key to be changed/recreated when altering a database. | |
* | |
* @param actionA The first action | |
* @param actionB The second action | |
*/ | |
public void addEquivalentOnDeleteActions(CascadeActionEnum actionA, CascadeActionEnum actionB) | |
{ | |
if (!actionA.equals(actionB)) | |
{ | |
Set actionsEquivalentToActionA = (Set)_equivalentOnDeleteActions.get(actionA); | |
Set actionsEquivalentToActionB = (Set)_equivalentOnDeleteActions.get(actionB); | |
if (actionsEquivalentToActionA == null) | |
{ | |
actionsEquivalentToActionA = new HashSet(); | |
_equivalentOnDeleteActions.put(actionA, actionsEquivalentToActionA); | |
} | |
if (actionsEquivalentToActionB == null) | |
{ | |
actionsEquivalentToActionB = new HashSet(); | |
_equivalentOnDeleteActions.put(actionB, actionsEquivalentToActionB); | |
} | |
actionsEquivalentToActionA.add(actionB); | |
actionsEquivalentToActionB.add(actionA); | |
} | |
} | |
/** | |
* Determiones whether the two ON DELETE actions are equivalent. Equivalent actions will not | |
* cause a foreign key to be changed/recreated when altering a database. | |
* | |
* @param actionA The first action | |
* @param actionB The second action | |
* @return <code>true</code> if the two actions are equivalent | |
*/ | |
public boolean areEquivalentOnDeleteActions(CascadeActionEnum actionA, CascadeActionEnum actionB) | |
{ | |
Set actionsEquivalentToActionA = (Set)_equivalentOnDeleteActions.get(actionA); | |
return actionsEquivalentToActionA == null ? false : actionsEquivalentToActionA.contains(actionB); | |
} | |
} |