| /** |
| * <copyright> |
| * |
| * Copyright (c) 2005-2013 Springsite BV (The Netherlands) and others |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Martin Taal - Initial API and implementation |
| * Jason Henriksen - Mapping File Path |
| * Jason Henriksen - XSDDate and XSDDateTime constants |
| * </copyright> |
| * |
| * $Id: PersistenceOptions.java,v 1.71 2011/10/29 06:12:48 mtaal Exp $ |
| */ |
| |
| package org.eclipse.emf.teneo; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Modifier; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Properties; |
| import java.util.regex.Pattern; |
| |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.eclipse.emf.teneo.annotations.pannotation.CascadeType; |
| import org.eclipse.emf.teneo.extension.ExtensionPoint; |
| |
| /** |
| * Defines the property names used in the persistence mapping. |
| * <p> |
| * As a convenience, this class offers type-safe property accessor wrappers. |
| * |
| * @author <a href="mailto:mtaal@elver.org">Martin Taal</a> |
| * @version $Revision: 1.71 $ |
| */ |
| public class PersistenceOptions implements ExtensionPoint { |
| |
| public static final String DEFAULT_CLASSPATH_FILENAME = "/teneo-persistence.properties"; |
| |
| public static final String RUNTIME_PREFIX = "teneo.runtime."; |
| |
| public static final String MAPPING_PREFIX = "teneo.mapping."; |
| |
| public static final String NAMING_PREFIX = "teneo.naming."; |
| |
| /** The logger */ |
| private static Log log = LogFactory.getLog(PersistenceOptions.class); |
| |
| // START: ++++++++++++++++++++++ AUDITING Naming related Options |
| // ++++++++++++++++++++++++++++++++++++ |
| |
| public static final String ENABLE_AUDITING = MAPPING_PREFIX + "auditing.enable"; |
| /** |
| * Automatically prune/delete entries older than this many days, default is zero, disabling the |
| * pruning process. |
| */ |
| public static final String AUDITING_PRUNE_OLD_ENTRIES_DAYS = MAPPING_PREFIX |
| + "auditing.prune.days"; |
| public static final String AUDITING_PRUNE_COMMIT_INTERVAL = MAPPING_PREFIX |
| + "auditing.prune.commit.interval"; |
| public static final String AUDITING_DB_SCHEMA = MAPPING_PREFIX + "auditing.database.schema"; |
| public static final String AUDITING_ENTITY_PREFIX = NAMING_PREFIX + "auditing.entity.prefix"; |
| public static final String AUDITING_ENTITY_POSTFIX = NAMING_PREFIX + "auditing.entity.postfix"; |
| public static final String AUDITING_JOINTABLE_POSTFIX = NAMING_PREFIX |
| + "auditing.jointable.postfix"; |
| public static final String AUDITING_PERSISTENCE_XML = MAPPING_PREFIX + "auditing.persistence_xml"; |
| |
| // START: ++++++++++++++++++++++ SQL Naming related Options |
| // ++++++++++++++++++++++++++++++++++++ |
| |
| /** |
| * DiscriminatorColumn name, default is DTYPE. |
| */ |
| public static final String DISCRIMINATOR_COLUMN_NAME = NAMING_PREFIX |
| + "discriminator_column_name"; |
| |
| /** |
| * Join table naming strategy, two values: ejb3 and unique |
| * |
| * @Deprecated use the extensionManager concept |
| */ |
| public static final String JOIN_TABLE_NAMING_STRATEGY = NAMING_PREFIX |
| + "join_table_naming_strategy"; |
| |
| /** |
| * Deprecated use JOIN_TABLE_NAMING_STRATEGY |
| * |
| * @Deprecated |
| */ |
| public static final String JOIN_TABLE_NAMING_STRATEGY_OLD = MAPPING_PREFIX |
| + "join_table_naming_strategy"; |
| |
| /** |
| * Join column naming strategy, two values: unique and simple. unique is the default and results |
| * in guaranteed unique naming for the join columns simple will always try to use minimal name |
| * lengths and will most of the time just use the efeaturename. |
| */ |
| public static final String JOIN_COLUMN_NAMING_STRATEGY = NAMING_PREFIX |
| + "join_column_naming_strategy"; |
| |
| /** The column name of the id column in the idbag, default is id */ |
| public static final String IDBAG_ID_COLUMN_NAME = NAMING_PREFIX + "idbag_id_column_name"; |
| |
| /** Name of version column, default value is e_version */ |
| public static final String VERSION_COLUMN_NAME = NAMING_PREFIX + "version_column"; |
| |
| /** Name of id column, default value is e_id */ |
| public static final String ID_COLUMN_NAME = NAMING_PREFIX + "default_id_column"; |
| |
| /** |
| * Truncate the column name if the length is larger than this property. In case of concatenating |
| * property names for foreign keys |
| */ |
| public static final String MAXIMUM_SQL_NAME_LENGTH = NAMING_PREFIX + "max_sql_name_length"; |
| |
| /** |
| * The option which determines the casing of columns and table names, lowercase will result in |
| * lowercase letters, uppercase in uppercase, none will just work as it did until now |
| */ |
| public static final String SQL_CASE_STRATEGY = NAMING_PREFIX + "strategy"; |
| |
| /** |
| * If set then the system will generate readable foreign key names. The default is true. Set to |
| * false for backward compatibility. Note that before the default value of this property was |
| * false. |
| */ |
| public static final String SET_FOREIGN_KEY_NAME = NAMING_PREFIX + "set_foreign_key_name"; |
| |
| /** |
| * The escape character to use when escaping table and column names. Standard Hibernate uses the ` |
| * (backtick). This is the default value. |
| */ |
| public static final String SQL_NAME_ESCAPE_CHARACTER = MAPPING_PREFIX |
| + "sql_name_escape_character"; |
| |
| /** |
| * The sql name strategy, if not set then the ClassicSQLNameStrategy is used. |
| * |
| * @Deprecated use the extensionManager concept |
| */ |
| public static final String SQL_NAME_STRATEGY = NAMING_PREFIX + "sql_name_strategy"; |
| |
| /** |
| * The Table name prefix, as a default set to "". |
| */ |
| public static final String SQL_TABLE_NAME_PREFIX = NAMING_PREFIX + "sql_table_name_prefix"; |
| |
| /** |
| * The Column name prefix, as a default set to "". |
| */ |
| public static final String SQL_COLUMN_NAME_PREFIX = NAMING_PREFIX + "sql_column_name_prefix"; |
| |
| /** |
| * The FK name prefix, as a default set to "". |
| */ |
| public static final String SQL_FOREIGN_KEY_NAME_PREFIX = NAMING_PREFIX + "sql_fk_name_prefix"; |
| |
| /** |
| * The Index name prefix, as a default set to "". |
| */ |
| public static final String SQL_INDEX_KEY_NAME_PREFIX = NAMING_PREFIX + "sql_index_name_prefix"; |
| |
| /** |
| * Controls if manually set sql names (table name, column names) should also be truncated or |
| * cased. Default is true for backward compatability. |
| */ |
| public static final String AUTO_ADAPT_MANUAL_SET_SQL_NAMES = NAMING_PREFIX |
| + "auto_adapt_manual_set_sql_names"; |
| |
| // END: ++++++++++++++++++++++ SQL Naming related Options |
| // ++++++++++++++++++++++++++++++++++++ |
| |
| /** |
| * Controls if non-mutable eclasses should have a discriminator or version column. Default is |
| * false. |
| * |
| * @Deprecated use the extensionManager concept |
| */ |
| public static final String SQL_DISCRIMINATOR_VERSION_IMMUTABLE_ECLASS = NAMING_PREFIX |
| + "sql_discriminator_version_immutable_eclass"; |
| |
| /** |
| * Controls how the econtainer feature id is persisted. There are three values: featureid or |
| * featurename |
| * |
| * @Deprecated use the extensionManager concept |
| */ |
| public static final String ECONTAINER_FEATURE_PERSISTENCE_STRATEGY = NAMING_PREFIX |
| + "econtainer_feature_persistence_strategy"; |
| |
| /** |
| * see bugzilla 227673, option can be used to set the hibernate usertype used for xsd date and xsd |
| * date time fields. |
| */ |
| public static final String USER_XSDDATE_TYPE = MAPPING_PREFIX + "UserDateType"; |
| public static final String USER_XSDDATETIME_TYPE = MAPPING_PREFIX + "UserDateTimeType"; |
| public static final String USER_XSDTIME_TYPE = MAPPING_PREFIX + "UserTimeType"; |
| |
| /** |
| * This option can be used to control the actual xsd date class used, as a default the |
| * javax.xml.datatype.XMLGregorianCalendar class is used. |
| */ |
| public static final String XSDDATE_CLASS = MAPPING_PREFIX + "XSDDateClass"; |
| |
| /** |
| * The default length of a varchar column. Normally hibernate will choose to set this to 255. |
| */ |
| public static final String DEFAULT_VARCHAR_LENGTH = MAPPING_PREFIX + "default_varchar_length"; |
| |
| /** |
| * The maximum length of the comments which are copied from the model to the mapping file. The |
| * default is zero which means no comments are copied from the model to the mapping. |
| */ |
| public static final String MAX_COMMENT_LENGTH = MAPPING_PREFIX + "max_comment_length"; |
| |
| /** |
| * EClass marked with Embeddable is always embedded, default is false. If this is set to true then |
| * it is not required anymore to set a |
| * |
| * @Embedded annotation on an ereference, |
| * @Embeddable on the EClass is then sufficient. |
| */ |
| public static final String MAP_EMBEDDABLE_AS_EMBEDDED = MAPPING_PREFIX |
| + "map_embeddable_as_embedded"; |
| |
| /** Optimistic locking */ |
| public static final String OPTIMISTIC = MAPPING_PREFIX + "optimistic_locking"; |
| |
| /** |
| * Add an index for each foreign key mapping. Some databases do not add an index for a foreign key |
| * automatically. Setting this to true will automatically add an index field to each foreign key. |
| */ |
| public static final String ADD_INDEX_FOR_FOREIGN_KEY = MAPPING_PREFIX + "add_index_for_fk"; |
| |
| public static final String HIBERNATE_VERSION = MAPPING_PREFIX + "hibernate.version"; |
| |
| /** |
| * Set or not set the cascade attribute on a mto, mtm or otm non-containment relation. The |
| * backward compatible value is true. The better performing value is false. The default is false. |
| * |
| * @Deprecated use CASCADE_POLICY_ON_NON_CONTAINMENT |
| */ |
| public static final String SET_DEFAULT_CASCADE_ON_NON_CONTAINMENT = MAPPING_PREFIX |
| + "set_default_cascade_on_non_containment"; |
| |
| /** Inheritance mapping */ |
| public static final String INHERITANCE_MAPPING = MAPPING_PREFIX + "inheritance"; |
| |
| /** |
| * Can be set to force an update of the schema when the application starts. Note this option is |
| * only meaningfull for jpox, for hibernate use the hibernate property: hibernate.hbm2ddl_auto |
| */ |
| public static final String UPDATE_SCHEMA = RUNTIME_PREFIX + "update_schema"; |
| |
| /** Force all containment relations to be eagerly loaded or not */ |
| public static final String FETCH_CONTAINMENT_EAGERLY = MAPPING_PREFIX |
| + "fetch_containment_eagerly"; |
| |
| /** |
| * Force all associations to be extra lazy loaded See here http://sites.google |
| * .com/a/pintailconsultingllc.com/java/hibernate-extra-lazy -collection-fetching for some |
| * information. |
| * |
| * Default is false. |
| */ |
| public static final String FETCH_ASSOCIATION_EXTRA_LAZY = MAPPING_PREFIX |
| + "fetch_one_to_many_extra_lazy"; |
| |
| /** |
| * Set cascade all (incl. orphan delete) on containment relation. |
| * |
| * @Deprecated use CASCADE_POLICY_ON_CONTAINMENT |
| */ |
| public static final String SET_CASCADE_ALL_ON_CONTAINMENT = MAPPING_PREFIX |
| + "cascade_all_on_containment"; |
| |
| /** |
| * Can be used to set custom cascade policy for containment : <br> |
| * <code>ALL</code> or a combination of (<code>REMOVE</code>, <code>REFRESH</code>, |
| * <code>PERSIST</code>, <code>MERGE</code>) <br> |
| * e.g. : REMOVE,PERSIST,MERGE <br> |
| * Warning : ALL != REMOVE,REFRESH,PERSIST,MERGE <br> |
| * but ALL == REMOVE with delete Orphan, REFRESH,PERSIST,MERGE |
| */ |
| public static final String CASCADE_POLICY_ON_CONTAINMENT = MAPPING_PREFIX |
| + "cascade_policy_on_containment"; |
| |
| /** |
| * Can be used to set custom cascade policy for non containment : <br> |
| * a combination of (<code>REFRESH</code>,<code>PERSIST</code>, <code>MERGE</code>) e.g. : |
| * PERSIST,MERGE |
| */ |
| public static final String CASCADE_POLICY_ON_NON_CONTAINMENT = MAPPING_PREFIX |
| + "cascade_policy_on_non_containment"; |
| |
| /** |
| * Can be used to control if the entity ann. should be added automatically to the model elements |
| * or that the default annotator should work according to the ejb3 spec. |
| */ |
| public static final String SET_ENTITY_AUTOMATICALLY = MAPPING_PREFIX + "set_entity_automatically"; |
| |
| /** |
| * Map all lists as a bag to the db (does not map the list index to the db), default is false |
| */ |
| public static final String ALWAYS_MAP_LIST_AS_BAG = MAPPING_PREFIX + "always_map_list_as_bag"; |
| |
| /** |
| * Map all lists as a hibernate idbag to the db (does not map the list index to the db), default |
| * is false |
| */ |
| public static final String MAP_ALL_LISTS_AS_IDBAG = MAPPING_PREFIX + "map_all_lists_as_idbag"; |
| |
| /** Use static hibernate mapping file */ |
| public static final String USE_MAPPING_FILE = MAPPING_PREFIX + "hibernate_mapping_file"; |
| |
| /** |
| * The complete resource path to the mapping file, can be used instead of the USE_MAPPING_FILE |
| * option |
| */ |
| public static final String MAPPING_FILE_PATH = MAPPING_PREFIX + "mapping_file_name"; |
| |
| /** |
| * Automatically add @Id to ID feature |
| * |
| * @id annotation to ID xsd type |
| */ |
| public static final String ID_FEATURE_AS_PRIMARY_KEY = NAMING_PREFIX |
| + "id_feature_as_primary_key"; |
| |
| /** |
| * Automatically add |
| * |
| * @GeneratedValue to ID feature for which |
| * @Id is added automatically, default is true. |
| */ |
| public static final String SET_GENERATED_VALUE_ON_ID_FEATURE = NAMING_PREFIX |
| + "set_generated_value_on_id_feature"; |
| |
| /** |
| * The name of the id feature if no feature has an id. |
| * |
| * @id annotation |
| */ |
| public static final String DEFAULT_ID_FEATURE_NAME = NAMING_PREFIX + "default_id_feature"; |
| |
| /** |
| * The path of the persistence XML file. |
| */ |
| public static final String PERSISTENCE_XML = MAPPING_PREFIX + "persistence_xml"; |
| |
| /** |
| * Lenient parsing of persistence xml, ignore missing epackages/efeatures and such |
| */ |
| public static final String PERSISTENCE_XML_PARSE_LENIENT = MAPPING_PREFIX |
| + "persistence_xml.parse.lenient"; |
| |
| /** |
| * Ignore mapping EAnnotations. Primarily meant for test cases that use Persistence XML mapping, |
| * so that they can reuse the same sample models. |
| */ |
| public static final String IGNORE_EANNOTATIONS = MAPPING_PREFIX + "ignore_eannotations"; |
| |
| /** |
| * Map all emaps as true hibernate maps, default is true. In EMF an EMap is in fact an EList with |
| * Map entries. Originally Teneo maps this as a hibernate list. In the new behavior hibernate can |
| * map the emap as a real map. The default is true. |
| */ |
| public static final String EMAP_AS_TRUE_MAP = MAPPING_PREFIX + "emap_as_true_map"; |
| |
| /** |
| * This option controls if in case of hibernate also a name attribute should be added to the |
| * class/subclass tag. By adding this a class is mapped as an entity as well as a normal class. |
| * Also mapping as a normal class has the advantage that proxies can be used and that queries can |
| * use actual class names and interface names. This option is really there for backward |
| * compatibility. There are no apparent dis-advantages of adding a name attribute so the default |
| * of this option is true. Note that an eclass must have an implementation class otherwise this |
| * option has no effect. Interfaces are for example always mapped as an entity. |
| */ |
| public static final String ALSO_MAP_AS_CLASS = MAPPING_PREFIX + "also_map_as_class"; |
| |
| /** |
| * This option controls if as a default all classes should be proxied (for hibernate). This means |
| * that you don't need to add a |
| * |
| * @Proxy annotation to each eclass. As a default Teneo will use the eclass interface as the proxy |
| * class. When this is set to true then the option ALSO_MAP_AS_CLASS should also be true. |
| */ |
| public static final String SET_PROXY = MAPPING_PREFIX + "set_proxy"; |
| |
| /** |
| * This option forces lazy=true without the proxy attribute in the hibernate mapping. |
| */ |
| public static final String FORCE_LAZY = MAPPING_PREFIX + "force_lazy"; |
| |
| /** |
| * Disable EContainer mapping. |
| */ |
| public static final String DISABLE_ECONTAINER_MAPPING = MAPPING_PREFIX + "disable_econtainer"; |
| |
| /** |
| * Option to specify that for non-contained one-to-many always a join table is used, default is |
| * true |
| */ |
| public static final String JOIN_TABLE_FOR_NON_CONTAINED_ASSOCIATIONS = MAPPING_PREFIX |
| + "join_table_for_non_contained_associations"; |
| |
| /** |
| * Determines whether to always include a version mapping even if one is not specified. Defaults |
| * to "true" |
| */ |
| public static final String ALWAYS_VERSION = MAPPING_PREFIX + "always_version"; |
| |
| /** |
| * The default cache strategy, can be one of: NONE, READ_ONLY, NONSTRICT_READ_ONLY, READ_WRITE, |
| * TRANSACTIONAl. If different than NONE (=default) then for Hibernate every class will be |
| * second-level cached! |
| */ |
| public static final String DEFAULT_CACHE_STRATEGY = MAPPING_PREFIX + "default_cache_strategy"; |
| |
| /** The default time/date type used */ |
| public static final String DEFAULT_TEMPORAL_VALUE = MAPPING_PREFIX + "default_temporal"; |
| |
| /** |
| * If true then EAttributes which are not set are stored as null in the database, if false then |
| * the default values is stored in the database. |
| */ |
| public static final String HANDLE_UNSET_AS_NULL = RUNTIME_PREFIX + "handle_unset_as_null"; |
| |
| /** |
| * This option controls if the size operation on an EList will load it's content from the |
| * database. The default is false, to maintain backward compatibility. If true then the size |
| * operation is done using a separate query. |
| */ |
| public static final String ELIST_EFFICIENT_SIZE_OPERATION = RUNTIME_PREFIX |
| + "elist_efficient_size_operation"; |
| |
| /** |
| * When an unset feature is persisted, the database will get a null value, default is false. |
| * |
| * @deprecated note the same as {@link #HANDLE_UNSET_AS_NULL} use that persistence option. |
| */ |
| public static final String CONVERT_UNSET_TO_NULL = RUNTIME_PREFIX + "convert_unset_to_null"; |
| |
| /** |
| * If set to true then the document root is also mapped. |
| */ |
| public static final String MAP_DOCUMENT_ROOT = MAPPING_PREFIX + "map_document_root"; |
| |
| /** |
| * If set to true then the system will automatically add referenced epackages |
| */ |
| public static final String AUTO_ADD_REFERENCED_EPACKAGES = MAPPING_PREFIX |
| + "auto_add_referenced_epackages"; |
| |
| /** |
| * If set to true then the system will map all eclasses as an EAV mapping. See |
| * http://www.elver.org/hibernate/eav_mapping.html |
| */ |
| public static final String EAV_MAPPING = MAPPING_PREFIX + "eav_mapping"; |
| |
| /** |
| * If set then the eav mapping file is read from the location defined by this property. |
| */ |
| public static final String EAV_MAPPING_FILE = MAPPING_PREFIX + "eav_location"; |
| |
| /** |
| * Map the FeatureMap as a component entity |
| */ |
| public static final String FEATUREMAP_AS_COMPONENT = MAPPING_PREFIX + "featuremap_as_component"; |
| |
| /** |
| * Additional sources which are taken into account parsing model annotations. The value can be a |
| * comma delimited list of source values. |
| */ |
| public static final String EXTRA_ANNOTATION_SOURCES = MAPPING_PREFIX + "extra_annotation_sources"; |
| |
| public final static String ECONTAINER_CLASS_COLUMN = "econtainer_class_column"; |
| public final static String ECONTAINER_COLUMN = "e_container_column"; |
| public final static String ECONTAINER_FEATURE_NAME_COLUMN = "e_container_feature_name_column"; |
| |
| /** Returns the default properties used in the system */ |
| public static Properties getDefaultProperties() { |
| final Properties props = new Properties(); |
| |
| props.setProperty(ENABLE_AUDITING, "false"); |
| props.setProperty(AUDITING_PRUNE_OLD_ENTRIES_DAYS, "0"); |
| props.setProperty(AUDITING_PRUNE_COMMIT_INTERVAL, "1000"); |
| |
| props.setProperty(AUDITING_DB_SCHEMA, ""); |
| props.setProperty(AUDITING_ENTITY_PREFIX, ""); |
| props.setProperty(AUDITING_ENTITY_POSTFIX, "Auditing"); |
| props.setProperty(AUDITING_JOINTABLE_POSTFIX, "Auditing"); |
| |
| props.setProperty(HANDLE_UNSET_AS_NULL, "false"); |
| props.setProperty(CONVERT_UNSET_TO_NULL, "false"); |
| props.setProperty(JOIN_TABLE_FOR_NON_CONTAINED_ASSOCIATIONS, "true"); |
| props.setProperty(USE_MAPPING_FILE, "false"); |
| // props.setProperty(MAPPING_FILE_PATH, null); // null is the default |
| // anyway |
| props.setProperty(SET_CASCADE_ALL_ON_CONTAINMENT, ""); |
| props.setProperty(CASCADE_POLICY_ON_CONTAINMENT, "ALL"); |
| props.setProperty(OPTIMISTIC, "true"); |
| props.setProperty(UPDATE_SCHEMA, "false"); |
| props.setProperty(FETCH_CONTAINMENT_EAGERLY, "false"); |
| props.setProperty(FETCH_ASSOCIATION_EXTRA_LAZY, "false"); |
| props.setProperty(SET_ENTITY_AUTOMATICALLY, "true"); |
| props.setProperty(VERSION_COLUMN_NAME, "e_version"); |
| props.setProperty(SQL_CASE_STRATEGY, "lowercase"); |
| props.setProperty(ID_COLUMN_NAME, "e_id"); |
| props.setProperty(DISABLE_ECONTAINER_MAPPING, "false"); |
| props.setProperty(MAXIMUM_SQL_NAME_LENGTH, "-1"); |
| props.setProperty(IGNORE_EANNOTATIONS, "false"); |
| props.setProperty(ALWAYS_VERSION, "true"); |
| props.setProperty(DEFAULT_CACHE_STRATEGY, "NONE"); |
| props.setProperty(DISCRIMINATOR_COLUMN_NAME, "DTYPE"); |
| props.setProperty(JOIN_TABLE_NAMING_STRATEGY, "unique"); |
| // props.setProperty(JOIN_TABLE_NAMING_STRATEGY_OLD, "unique"); |
| props.setProperty(JOIN_COLUMN_NAMING_STRATEGY, "unique"); |
| props.setProperty(DEFAULT_TEMPORAL_VALUE, "TIMESTAMP"); |
| props.setProperty(DEFAULT_ID_FEATURE_NAME, "e_id"); |
| props.setProperty(PERSISTENCE_XML_PARSE_LENIENT, "false"); |
| props.setProperty(ID_FEATURE_AS_PRIMARY_KEY, "true"); |
| props.setProperty(SET_GENERATED_VALUE_ON_ID_FEATURE, "true"); |
| props.setProperty(EMAP_AS_TRUE_MAP, "true"); |
| props.setProperty(ALWAYS_MAP_LIST_AS_BAG, "false"); |
| props.setProperty(ALSO_MAP_AS_CLASS, "true"); |
| props.setProperty(ELIST_EFFICIENT_SIZE_OPERATION, "false"); |
| props.setProperty(SET_PROXY, "false"); |
| props.setProperty(FORCE_LAZY, "false"); |
| props.setProperty(MAP_ALL_LISTS_AS_IDBAG, "false"); |
| props.setProperty(IDBAG_ID_COLUMN_NAME, "ID"); |
| props.setProperty(ADD_INDEX_FOR_FOREIGN_KEY, "false"); |
| props.setProperty(SET_DEFAULT_CASCADE_ON_NON_CONTAINMENT, ""); |
| props.setProperty(CASCADE_POLICY_ON_NON_CONTAINMENT, ""); |
| props.setProperty(SET_FOREIGN_KEY_NAME, "true"); |
| props.setProperty(MAP_EMBEDDABLE_AS_EMBEDDED, "false"); |
| props.setProperty(MAX_COMMENT_LENGTH, "0"); |
| props.setProperty(DEFAULT_VARCHAR_LENGTH, "-1"); |
| props.setProperty(SQL_NAME_ESCAPE_CHARACTER, "`"); |
| props.setProperty(USER_XSDDATE_TYPE, "org.eclipse.emf.teneo.hibernate.mapping.XSDDate"); |
| props.setProperty(USER_XSDDATETIME_TYPE, "org.eclipse.emf.teneo.hibernate.mapping.XSDDateTime"); |
| props.setProperty(USER_XSDTIME_TYPE, "org.eclipse.emf.teneo.hibernate.mapping.XSDDateTime"); |
| props.setProperty(XSDDATE_CLASS, "javax.xml.datatype.XMLGregorianCalendar"); |
| props.setProperty(SQL_DISCRIMINATOR_VERSION_IMMUTABLE_ECLASS, "true"); |
| props.setProperty(ECONTAINER_FEATURE_PERSISTENCE_STRATEGY, "FEATURENAME"); |
| props.setProperty(SQL_TABLE_NAME_PREFIX, ""); |
| props.setProperty(SQL_COLUMN_NAME_PREFIX, ""); |
| props.setProperty(SQL_FOREIGN_KEY_NAME_PREFIX, ""); |
| props.setProperty(SQL_INDEX_KEY_NAME_PREFIX, ""); |
| props.setProperty(MAP_DOCUMENT_ROOT, "false"); |
| props.setProperty(EAV_MAPPING, "false"); |
| props.setProperty(AUTO_ADD_REFERENCED_EPACKAGES, "false"); |
| props.setProperty(ECONTAINER_CLASS_COLUMN, Constants.COLUMN_ECONTAINER_CLASS); |
| props.setProperty(ECONTAINER_COLUMN, Constants.COLUMN_ECONTAINER); |
| props.setProperty(ECONTAINER_FEATURE_NAME_COLUMN, Constants.COLUMN_ECONTAINER_FEATURE_NAME); |
| props.setProperty(FEATUREMAP_AS_COMPONENT, "false"); |
| props.setProperty(EXTRA_ANNOTATION_SOURCES, ""); |
| props.setProperty(AUTO_ADAPT_MANUAL_SET_SQL_NAMES, "true"); |
| |
| return props; |
| } |
| |
| /** |
| * The wrapped Properties instance. |
| */ |
| private final Properties properties; |
| |
| /** |
| * @return value of {@link #ENABLE_AUDITING} |
| */ |
| public boolean isEnableAuditing() { |
| return Boolean.valueOf(properties.getProperty(ENABLE_AUDITING)).booleanValue(); |
| } |
| |
| /** |
| * @return value of {@link #HIBERNATE_VERSION} |
| */ |
| public String getHibernateVersion() { |
| return properties.getProperty(HIBERNATE_VERSION); |
| } |
| |
| /** |
| * @return value of {@link #AUDITING_ENTITY_PREFIX} |
| */ |
| public String getAuditingEntityPrefix() { |
| final String value = properties.getProperty(AUDITING_ENTITY_PREFIX); |
| if (value == null) { |
| return ""; |
| } |
| return value; |
| } |
| |
| /** |
| * @return value of {@link #AUDITING_DB_SCHEMA} |
| */ |
| public String getAuditingDBSchema() { |
| final String value = properties.getProperty(AUDITING_DB_SCHEMA); |
| if (value == null) { |
| return ""; |
| } |
| return value; |
| } |
| |
| /** |
| * @return value of {@link #AUDITING_PRUNE_OLD_ENTRIES_DAYS} |
| */ |
| public long getAuditingPruneDays() { |
| final String value = properties.getProperty(AUDITING_PRUNE_OLD_ENTRIES_DAYS); |
| try { |
| return Long.parseLong(value); |
| } catch (NumberFormatException e) { |
| return 0; |
| } |
| } |
| |
| /** |
| * @return value of {@link #AUDITING_PRUNE_COMMIT_INTERVAL} |
| */ |
| public long getAuditingPruneCommitInterval() { |
| final String value = properties.getProperty(AUDITING_PRUNE_COMMIT_INTERVAL); |
| try { |
| return Long.parseLong(value); |
| } catch (NumberFormatException e) { |
| return 1000; |
| } |
| } |
| |
| /** |
| * @return value of {@link #AUDITING_ENTITY_POSTFIX} |
| */ |
| public String getAuditingEntityPostfix() { |
| final String value = properties.getProperty(AUDITING_ENTITY_POSTFIX); |
| if (value == null) { |
| return ""; |
| } |
| return value; |
| } |
| |
| /** |
| * @return value of {@link #AUDITING_JOINTABLE_POSTFIX} |
| */ |
| public String getAuditingJoinTablePostfix() { |
| final String value = properties.getProperty(AUDITING_JOINTABLE_POSTFIX); |
| if (value == null) { |
| return ""; |
| } |
| return value; |
| } |
| |
| /** |
| * @return value of {@link #DISCRIMINATOR_COLUMN_NAME} |
| */ |
| public String getDiscriminatorColumnName() { |
| return properties.getProperty(DISCRIMINATOR_COLUMN_NAME); |
| } |
| |
| /** |
| * @return value of {@link #EXTRA_ANNOTATION_SOURCES} |
| */ |
| public String getExtraAnnotationSources() { |
| return properties.getProperty(EXTRA_ANNOTATION_SOURCES); |
| } |
| |
| /** |
| * @return value of {@link #FEATUREMAP_AS_COMPONENT} |
| */ |
| public boolean isMapFeatureMapAsComponent() { |
| return Boolean.valueOf(properties.getProperty(FEATUREMAP_AS_COMPONENT)).booleanValue(); |
| } |
| |
| /** |
| * @return value of {@link AUTO_ADAPT_MANUAL_SET_SQL_NAMES} |
| */ |
| public boolean isAutoAdaptManualSQLNames() { |
| return Boolean.valueOf(properties.getProperty(AUTO_ADAPT_MANUAL_SET_SQL_NAMES)).booleanValue(); |
| } |
| |
| /** |
| * @return value of {@link #ECONTAINER_COLUMN} |
| */ |
| public String getEContainerColumn() { |
| return properties.getProperty(ECONTAINER_COLUMN); |
| } |
| |
| /** |
| * @return value of {@link #ECONTAINER_CLASS_COLUMN} |
| */ |
| public String getEContainerClassColumn() { |
| return properties.getProperty(ECONTAINER_CLASS_COLUMN); |
| } |
| |
| /** |
| * @return value of {@link #ECONTAINER_FEATURE_NAME_COLUMN} |
| */ |
| public String getEContainerFeatureNameColumn() { |
| return properties.getProperty(ECONTAINER_FEATURE_NAME_COLUMN); |
| } |
| |
| /** |
| * @return value of {@link #EAV_MAPPING} |
| */ |
| public boolean isEAVMapping() { |
| return Boolean.valueOf(properties.getProperty(EAV_MAPPING)).booleanValue(); |
| } |
| |
| /** |
| * @return value of {@link #EAV_MAPPING_FILE} |
| */ |
| public String getEAVMappingFile() { |
| return properties.getProperty(EAV_MAPPING_FILE); |
| } |
| |
| /** |
| * @return value of {@link #AUTO_ADD_REFERENCED_EPACKAGES} |
| */ |
| public boolean isAutoAddReferencedEPackages() { |
| return Boolean.valueOf(properties.getProperty(AUTO_ADD_REFERENCED_EPACKAGES)).booleanValue(); |
| } |
| |
| /** |
| * @return value of {@link #MAP_DOCUMENT_ROOT} |
| */ |
| public boolean isMapDocumentRoot() { |
| return Boolean.valueOf(properties.getProperty(MAP_DOCUMENT_ROOT)).booleanValue(); |
| } |
| |
| /** |
| * @return value of the {@link #HANDLE_UNSET_AS_NULL} option |
| */ |
| public boolean getHandleUnsetAsNull() { |
| return Boolean.valueOf(properties.getProperty(HANDLE_UNSET_AS_NULL)).booleanValue(); |
| } |
| |
| /** |
| * @return value of the {@link #CONVERT_UNSET_TO_NULL} option |
| */ |
| public boolean getConvertUnsetToNull() { |
| return Boolean.valueOf(properties.getProperty(CONVERT_UNSET_TO_NULL)).booleanValue(); |
| } |
| |
| /** |
| * Construct a new instance using Properties. |
| */ |
| public PersistenceOptions(Properties properties) { |
| this.properties = getDefaultProperties(); |
| |
| if (properties != null) { |
| this.properties.putAll(properties); |
| } |
| |
| logProperties(); |
| } |
| |
| /** |
| * Constructs a new instance by loading properties from "/elver-persistence.properties" at the |
| * root of the classpath. |
| */ |
| public PersistenceOptions() { |
| this.properties = getDefaultProperties(); |
| |
| final Properties props = new Properties(); |
| InputStream in = null; |
| try { |
| in = this.getClass().getResourceAsStream(DEFAULT_CLASSPATH_FILENAME); |
| if (in != null) { |
| if (log.isDebugEnabled()) { |
| log.debug("Loading persistence options from classpath \"" + DEFAULT_CLASSPATH_FILENAME |
| + "\"."); |
| } |
| props.load(in); |
| } |
| } catch (IOException e) { |
| throw new RuntimeException("Error loading \"" + DEFAULT_CLASSPATH_FILENAME |
| + "\" from classpath:" + e.getMessage(), e); |
| } finally { |
| try { |
| if (in != null) { |
| in.close(); |
| } |
| } catch (IOException e) { |
| // Ignore. |
| } |
| } |
| this.properties.putAll(props); |
| |
| logProperties(); |
| } |
| |
| /** Dump the props */ |
| public void logProperties() { |
| if (!log.isDebugEnabled()) { |
| return; |
| } |
| log.debug("Properties of PersistenceOptions:"); |
| for (Object key : properties.keySet()) { |
| log.debug(key + ": " + properties.get(key)); |
| } |
| } |
| |
| public String getSQLTableNamePrefix() { |
| return properties.getProperty(SQL_TABLE_NAME_PREFIX); |
| } |
| |
| public String getSQLColumnNamePrefix() { |
| return properties.getProperty(SQL_COLUMN_NAME_PREFIX); |
| } |
| |
| public String getSQLForeignKeyNamePrefix() { |
| return properties.getProperty(SQL_FOREIGN_KEY_NAME_PREFIX); |
| } |
| |
| public String getSQLIndexNamePrefix() { |
| return properties.getProperty(SQL_INDEX_KEY_NAME_PREFIX); |
| } |
| |
| /** Return the default temporal value */ |
| public String getDefaultTemporalValue() { |
| return properties.getProperty(DEFAULT_TEMPORAL_VALUE); |
| } |
| |
| /** Return the IDBAG_ID_COLUMN_NAME */ |
| public String getIDBagIDColumnName() { |
| return getSQLColumnNamePrefix() + properties.getProperty(IDBAG_ID_COLUMN_NAME); |
| } |
| |
| /** |
| * Returns the value of the EMAP_AS_TRUE_MAP option, default is false |
| */ |
| public boolean isMapEMapAsTrueMap() { |
| return Boolean.valueOf(properties.getProperty(EMAP_AS_TRUE_MAP)).booleanValue(); |
| } |
| |
| /** |
| * Returns the value of the SET_DEFAULT_CASCADE_ON_MTO_MTM option, default is false |
| */ |
| public boolean isSetDefaultCascadeOnNonContainment() { |
| String property = properties.getProperty(SET_DEFAULT_CASCADE_ON_NON_CONTAINMENT); |
| if (!property.equals("")) { |
| return Boolean.valueOf(property).booleanValue(); |
| } |
| return !properties.getProperty(CASCADE_POLICY_ON_NON_CONTAINMENT).equals(""); |
| } |
| |
| public boolean isSetCascadePolicyForNonContainment() { |
| return !properties.getProperty(CASCADE_POLICY_ON_NON_CONTAINMENT).equals(""); |
| } |
| |
| public String getCascadePolicyForContainment() { |
| return properties.getProperty(CASCADE_POLICY_ON_CONTAINMENT); |
| } |
| |
| public String getCascadePolicyForNonContainment() { |
| return properties.getProperty(CASCADE_POLICY_ON_NON_CONTAINMENT); |
| } |
| |
| /** |
| * Returns true if the CASCADE_POLICY_ON_NON_CONTAINMENT property contains the merge cascade type |
| */ |
| public boolean isSetCascadeMergeOnNonContainment() { |
| return isSetCascadeOnNonContainement(CascadeType.MERGE.getName()); |
| } |
| |
| /** |
| * Returns true if the CASCADE_POLICY_ON_NON_CONTAINMENT property contains the persist cascade |
| * type |
| */ |
| public boolean isSetCascadePersistOnNonContainment() { |
| return isSetCascadeOnNonContainement(CascadeType.PERSIST.getName()); |
| } |
| |
| /** |
| * Returns true if the CASCADE_POLICY_ON_NON_CONTAINMENT property contains the refresh cascade |
| * type |
| */ |
| public boolean isSetCascadeRefreshOnNonContainment() { |
| return isSetCascadeOnNonContainement(CascadeType.REFRESH.getName()); |
| } |
| |
| /** |
| * Returns true if the CASCADE_POLICY_ON_NON_CONTAINMENT property contains the given cascade type |
| */ |
| private boolean isSetCascadeOnNonContainement(String cascadeType) { |
| return isSetCascade(properties.getProperty(CASCADE_POLICY_ON_NON_CONTAINMENT), cascadeType); |
| } |
| |
| /** |
| * Returns the value of the SET_FOREIGN_KEY_NAME option, default is true |
| */ |
| public boolean isSetForeignKeyNames() { |
| return Boolean.valueOf(properties.getProperty(SET_FOREIGN_KEY_NAME)).booleanValue(); |
| } |
| |
| /** |
| * Returns the value of the ALSO_MAP_AS_CLASS option, default is false |
| */ |
| public boolean isAlsoMapAsClass() { |
| return Boolean.valueOf(properties.getProperty(ALSO_MAP_AS_CLASS)).booleanValue(); |
| } |
| |
| /** |
| * Returns the value of the ELIST_EFFICIENT_SIZE_OPERATION option, default is false |
| */ |
| public boolean isEListEfficientSizeOperation() { |
| return Boolean.valueOf(properties.getProperty(ELIST_EFFICIENT_SIZE_OPERATION)).booleanValue(); |
| } |
| |
| /** |
| * Returns the value of the MAP_EMBEDDABLE_AS_EMBEDDED option, default is false |
| */ |
| public boolean isMapEmbeddableAsEmbedded() { |
| return Boolean.valueOf(properties.getProperty(MAP_EMBEDDABLE_AS_EMBEDDED)).booleanValue(); |
| } |
| |
| /** |
| * Returns true if the proxy annotation should be added automatically |
| */ |
| public boolean isSetProxy() { |
| return Boolean.valueOf(properties.getProperty(SET_PROXY)).booleanValue(); |
| } |
| |
| /** |
| * Returns true if the lazy attribute should be forced to true in the hbm mapping. |
| */ |
| public boolean isForceLazy() { |
| return Boolean.valueOf(properties.getProperty(FORCE_LAZY)).booleanValue(); |
| } |
| |
| /** |
| * Returns the value of the ALWAYS_MAP_LIST_AS_BAG option, default is false |
| */ |
| public boolean alwaysMapListAsBag() { |
| return Boolean.valueOf(properties.getProperty(ALWAYS_MAP_LIST_AS_BAG)).booleanValue(); |
| } |
| |
| /** |
| * Returns the value of the MAP_ALL_LISTS_AS_IDBAG option, default is false |
| */ |
| public boolean alwaysMapListAsIdBag() { |
| return Boolean.valueOf(properties.getProperty(MAP_ALL_LISTS_AS_IDBAG)).booleanValue(); |
| } |
| |
| /** Returns the value of the ADD_INDEX_FOR_FOREIGN_KEY option */ |
| public boolean isAddIndexForForeignKey() { |
| return Boolean.valueOf(properties.getProperty(ADD_INDEX_FOR_FOREIGN_KEY)).booleanValue(); |
| } |
| |
| /** |
| * Returns the value of the UseJoinTableForNonContainedAssociations option, default is false |
| */ |
| public boolean isJoinTableForNonContainedAssociations() { |
| return Boolean.valueOf(properties.getProperty(JOIN_TABLE_FOR_NON_CONTAINED_ASSOCIATIONS)) |
| .booleanValue(); |
| } |
| |
| /** Returns the value of the UseMappingFile option, default is false */ |
| public boolean isUseMappingFile() { |
| return Boolean.valueOf(properties.getProperty(USE_MAPPING_FILE)).booleanValue(); |
| } |
| |
| /** Returns the value of the MAPPING_FILE_PATH option, default is "" */ |
| public String getMappingFilePath() { |
| return properties.getProperty(MAPPING_FILE_PATH); |
| } |
| |
| /** Returns the value of the id feature as primary key */ |
| public boolean isIDFeatureAsPrimaryKey() { |
| return Boolean.valueOf(properties.getProperty(ID_FEATURE_AS_PRIMARY_KEY)).booleanValue(); |
| } |
| |
| /** Returns the value of the SET_GENERATED_VALUE_ON_ID_FEATURE option */ |
| public boolean isSetGeneratedValueOnIDFeature() { |
| return Boolean.valueOf(properties.getProperty(SET_GENERATED_VALUE_ON_ID_FEATURE)) |
| .booleanValue(); |
| } |
| |
| /** Returns the value of the orphan delete on containment, default is true */ |
| public boolean isSetCascadeAllOnContainment() { |
| if (!properties.getProperty(SET_CASCADE_ALL_ON_CONTAINMENT).equals("")) { |
| return Boolean.valueOf(properties.getProperty(SET_CASCADE_ALL_ON_CONTAINMENT)).booleanValue(); |
| } |
| return isSetCascadeOnContainement(CascadeType.ALL.getName()); |
| } |
| |
| /** |
| * Returns true if CASCADE_POLICY_ON_CONTAINMENT property contains the MERGE cascade type |
| */ |
| public boolean isSetCascadeMergeOnContainment() { |
| return isSetCascadeOnContainement(CascadeType.MERGE.getName()); |
| } |
| |
| /** |
| * Returns true if CASCADE_POLICY_ON_CONTAINMENT property contains the PERSIST cascade type |
| */ |
| public boolean isSetCascadePersistOnContainment() { |
| return isSetCascadeOnContainement(CascadeType.PERSIST.getName()); |
| } |
| |
| /** |
| * Returns true if CASCADE_POLICY_ON_CONTAINMENT property contains the REMOVE cascade type |
| */ |
| public boolean isSetCascadeRemoveOnContainment() { |
| return isSetCascadeOnContainement(CascadeType.REMOVE.getName()); |
| } |
| |
| /** |
| * Returns true if CASCADE_POLICY_ON_CONTAINMENT property contains the REFRESH cascade type |
| */ |
| public boolean isSetCascadeRefreshOnContainment() { |
| return isSetCascadeOnContainement(CascadeType.REFRESH.getName()); |
| } |
| |
| /** |
| * Returns true if CASCADE_POLICY_ON_CONTAINMENT property contains the given cascade type |
| */ |
| private boolean isSetCascadeOnContainement(String cascadeType) { |
| return isSetCascade(properties.getProperty(CASCADE_POLICY_ON_CONTAINMENT), cascadeType); |
| } |
| |
| /** Returns true if property contains the given cascade type */ |
| private boolean isSetCascade(String property, String cascadeType) { |
| return Pattern.matches(".*\\b" + cascadeType.toUpperCase() + "\\b.*", property.toUpperCase()); |
| } |
| |
| /** Returns the value of the Optimistic option, default is true */ |
| public boolean isUseOptimisticLocking() { |
| return Boolean.valueOf(properties.getProperty(OPTIMISTIC)).booleanValue(); |
| } |
| |
| /** Returns the value of the UpdateSchema option, default is true */ |
| public boolean isUpdateSchema() { |
| return Boolean.valueOf(properties.getProperty(UPDATE_SCHEMA)).booleanValue(); |
| } |
| |
| /** Returns the value of the fetch containment eagerly, default is false */ |
| public boolean isFetchContainmentEagerly() { |
| return Boolean.valueOf(properties.getProperty(FETCH_CONTAINMENT_EAGERLY)).booleanValue(); |
| } |
| |
| /** Returns the value of the fetch extra lazy option, default is false */ |
| public boolean isFetchAssociationExtraLazy() { |
| return Boolean.valueOf(properties.getProperty(FETCH_ASSOCIATION_EXTRA_LAZY)).booleanValue(); |
| } |
| |
| /** Is set entity automatically, default is true */ |
| public boolean isSetEntityAutomatically() { |
| return Boolean.valueOf(properties.getProperty(SET_ENTITY_AUTOMATICALLY)).booleanValue(); |
| } |
| |
| /** Returns the inheritance mapping strategy, can be null */ |
| public String getInheritanceMapping() { |
| return properties.getProperty(INHERITANCE_MAPPING); |
| } |
| |
| /** Returns the value of the version column option, returns null if not set */ |
| public String getVersionColumnName() { |
| return getSQLColumnNamePrefix() + properties.getProperty(VERSION_COLUMN_NAME); |
| } |
| |
| /** Returns the value of the naming strategy, default is lower case */ |
| public String getSQLCaseStrategy() { |
| return properties.getProperty(SQL_CASE_STRATEGY); |
| } |
| |
| /** Returns the value of the id column option, returns null if not set */ |
| public String getIdColumnName() { |
| return getSQLColumnNamePrefix() + properties.getProperty(ID_COLUMN_NAME); |
| } |
| |
| /** Returns the value of the default id property */ |
| public String getDefaultIDFeatureName() { |
| return properties.getProperty(DEFAULT_ID_FEATURE_NAME); |
| } |
| |
| /** Return the sql escape character, default is ` */ |
| public String getSqlNameEscapeCharacter() { |
| return properties.getProperty(SQL_NAME_ESCAPE_CHARACTER); |
| } |
| |
| /** Returns the value of the join table naming strategy */ |
| public String getJoinTableNamingStrategy() { |
| if (properties.get(JOIN_TABLE_NAMING_STRATEGY_OLD) != null) { |
| log.warn("The option " + JOIN_TABLE_NAMING_STRATEGY_OLD + " is deprecated, please use: " |
| + JOIN_TABLE_NAMING_STRATEGY); |
| return properties.getProperty(JOIN_TABLE_NAMING_STRATEGY); |
| } |
| return properties.getProperty(JOIN_TABLE_NAMING_STRATEGY); |
| } |
| |
| /** Returns the value of the join column naming strategy */ |
| public String getJoinColumnNamingStrategy() { |
| return properties.getProperty(JOIN_COLUMN_NAMING_STRATEGY); |
| } |
| |
| /** |
| * Returns the default second level caching strategy, default value is NONE (no second level |
| * caching). |
| */ |
| public String getDefaultCacheStrategy() { |
| return properties.getProperty(DEFAULT_CACHE_STRATEGY); |
| } |
| |
| /** Return the default varchar length */ |
| public int getDefaultVarCharLength() { |
| return Integer.parseInt(properties.getProperty(DEFAULT_VARCHAR_LENGTH)); |
| } |
| |
| /** Are econtainer mappings (hibernate) disabled */ |
| public boolean isDisableEContainerMapping() { |
| return Boolean.valueOf(properties.getProperty(DISABLE_ECONTAINER_MAPPING)).booleanValue(); |
| } |
| |
| /** Return the value of the MAX_COMMENT_LENGTH */ |
| public int getMaximumCommentLength() { |
| final String colLength = properties.getProperty(MAX_COMMENT_LENGTH); |
| try { |
| final int maxLength = Integer.parseInt(colLength); |
| return maxLength; |
| } catch (NumberFormatException e) { |
| log.error("Property " + MAXIMUM_SQL_NAME_LENGTH + " as a non-integer value: " + colLength |
| + " value is ignored"); |
| return 0; |
| } |
| } |
| |
| /** Return the max. sql name length, or -1 if not set or illegal */ |
| public int getMaximumSqlNameLength() { |
| final String colLength = properties.getProperty(MAXIMUM_SQL_NAME_LENGTH); |
| try { |
| final int maxLength = Integer.parseInt(colLength); |
| if (maxLength == 0) { |
| throw new TeneoException("The option MAXIMUM_SQL_NAME_LENGTH has a value of zero. " |
| + "This will result in empty column and table names in the mapping! " |
| + "Please change this option to a more usable value."); |
| } |
| if (maxLength < 4 && maxLength > -1) { |
| log.warn("The option MAXIMUM_SQL_NAME_LENGTH has a low value: " + maxLength |
| + ". Are you sure this is correct?"); |
| } |
| return maxLength; |
| } catch (NumberFormatException e) { |
| log.error("Property " + MAXIMUM_SQL_NAME_LENGTH + " as a non-integer value: " + colLength |
| + " value is ignored"); |
| return -1; |
| } |
| } |
| |
| /** |
| * Returns the value of the SQL_DISCRIMINATOR_VERSION_IMMUTABLE_ECLASS option. |
| */ |
| public Boolean isDiscriminatorVersionOnImmutableEClass() { |
| return Boolean.valueOf(properties.getProperty(SQL_DISCRIMINATOR_VERSION_IMMUTABLE_ECLASS)) |
| .booleanValue(); |
| } |
| |
| /** |
| * Returns the path of the XML persistence mapping file or null if the property has not been |
| * defined. |
| */ |
| public String getPersistenceXmlPath() { |
| return properties.getProperty(PERSISTENCE_XML); |
| } |
| |
| /** |
| * Returns the path of the auditing XML persistence mapping file or null if the property has not |
| * been defined. Can be used to influence the auditing persistence. |
| */ |
| public String getAuditingPersistenceXmlPath() { |
| return properties.getProperty(AUDITING_PERSISTENCE_XML); |
| } |
| |
| /** |
| * returns the value of the {@link #PERSISTENCE_XML_PARSE_LENIENT} |
| */ |
| public Boolean getPersistenceXmlParseLenient() { |
| return Boolean.valueOf(properties.getProperty(PERSISTENCE_XML_PARSE_LENIENT)); |
| } |
| |
| /** |
| * Returns a boolean indication whether to ignore mapping EAnnotations. |
| */ |
| public boolean isIgnoreEAnnotations() { |
| return Boolean.valueOf(properties.getProperty(IGNORE_EANNOTATIONS)).booleanValue(); |
| } |
| |
| /** |
| * Returns an array of all String constants. |
| * |
| * @return |
| */ |
| public static String[] propertyNames() { |
| final List<String> names = new ArrayList<String>(); |
| for (Field field : PersistenceOptions.class.getFields()) { |
| try { |
| if ((field.getModifiers() & Modifier.STATIC) > 0 & field.getType().equals(String.class)) { |
| final String value = (String) field.get(null); |
| if (value.startsWith("teneo.")) { |
| names.add(value); |
| } |
| } |
| } catch (IllegalAccessException e) { |
| } |
| } |
| Collections.sort(names); |
| return names.toArray(new String[names.size()]); |
| } |
| |
| public boolean getAlwaysVersion() { |
| return Boolean.valueOf(properties.getProperty(ALWAYS_VERSION)).booleanValue(); |
| } |
| |
| /** |
| * @return the properties |
| */ |
| public Properties getProperties() { |
| return properties; |
| } |
| |
| /** |
| * Creates the correct sql name strategy based on the String setting. |
| * |
| * @Deprecated use the SQLNameStrategy and extensionManager concept |
| */ |
| public String getSQLNameStrategy() { |
| return properties.getProperty(SQL_NAME_STRATEGY); |
| } |
| |
| public String getUserXSDDateType() { |
| return properties.getProperty(USER_XSDDATE_TYPE); |
| } |
| |
| public String getUserXSDTime() { |
| return properties.getProperty(USER_XSDTIME_TYPE); |
| } |
| |
| public String getUserXSDDateTime() { |
| return properties.getProperty(USER_XSDDATETIME_TYPE); |
| } |
| |
| public String getXSDDateClass() { |
| return properties.getProperty(XSDDATE_CLASS); |
| } |
| |
| public EContainerFeaturePersistenceStrategy getEContainerFeaturePersistenceStrategy() { |
| String strategy = properties.getProperty(ECONTAINER_FEATURE_PERSISTENCE_STRATEGY); |
| if (strategy == null) { |
| throw new TeneoException( |
| "Option ECONTAINER_FEATURE_PERSISTENCE_STRATEGY not set, please set it to one of: featureid, featurename, both"); |
| } |
| EContainerFeaturePersistenceStrategy result = EContainerFeaturePersistenceStrategy |
| .valueOf(strategy.toUpperCase()); |
| if (result == null) { |
| throw new TeneoException("Option ECONTAINER_FEATURE_PERSISTENCE_STRATEGY not set correctly (" |
| + strategy + "), please set it to one of: featureid, featurename, both"); |
| } |
| return result; |
| } |
| |
| public enum EContainerFeaturePersistenceStrategy { |
| FEATURENAME, FEATUREID, BOTH |
| } |
| } |