private void dissectProperty(int prefixLoc, String key, Properties properties) {
TypeOverrides cfgOverride = null;
int suffixLoc = -1;
if (!key.equals(INFINISPAN_CONFIG_RESOURCE_PROP)
&& (suffixLoc = key.indexOf(CONFIG_SUFFIX)) != -1) {
cfgOverride = getOrCreateConfig(prefixLoc, key, suffixLoc);
cfgOverride.setCacheName(ConfigurationHelper.extractPropertyValue(key, properties));
} else if ((suffixLoc = key.indexOf(STRATEGY_SUFFIX)) != -1) {
cfgOverride = getOrCreateConfig(prefixLoc, key, suffixLoc);
cfgOverride.setEvictionStrategy(ConfigurationHelper.extractPropertyValue(key, properties));
} else if ((suffixLoc = key.indexOf(WAKE_UP_INTERVAL_SUFFIX)) != -1) {
cfgOverride = getOrCreateConfig(prefixLoc, key, suffixLoc);
cfgOverride.setEvictionWakeUpInterval(
Long.parseLong(ConfigurationHelper.extractPropertyValue(key, properties)));
} else if ((suffixLoc = key.indexOf(MAX_ENTRIES_SUFFIX)) != -1) {
cfgOverride = getOrCreateConfig(prefixLoc, key, suffixLoc);
cfgOverride.setEvictionMaxEntries(ConfigurationHelper.getInt(key, properties, -1));
} else if ((suffixLoc = key.indexOf(LIFESPAN_SUFFIX)) != -1) {
cfgOverride = getOrCreateConfig(prefixLoc, key, suffixLoc);
cfgOverride.setExpirationLifespan(
Long.parseLong(ConfigurationHelper.extractPropertyValue(key, properties)));
} else if ((suffixLoc = key.indexOf(MAX_IDLE_SUFFIX)) != -1) {
cfgOverride = getOrCreateConfig(prefixLoc, key, suffixLoc);
cfgOverride.setExpirationMaxIdle(
Long.parseLong(ConfigurationHelper.extractPropertyValue(key, properties)));
}
// else if ((suffixLoc = key.indexOf(STATISTICS_SUFFIX)) != -1) {
// cfgOverride = getOrCreateConfig(prefixLoc, key, suffixLoc);
//
// cfgOverride.setExposeStatistics(Boolean.parseBoolean(PropertiesHelper.extractPropertyValue(key, properties)));
// }
}
public static int getLockTimeoutInMillis(Properties props) {
int timeout = -1;
try {
timeout = ConfigurationHelper.getInt(LOCK_TIMEOUT, props, -1);
} catch (Exception ignored) {
}
if (timeout < 0) {
timeout = MAXIMUM_LOCK_TIMEOUT;
}
return timeout;
}
@Override
public void configure(Type type, Properties params, ServiceRegistry serviceRegistry)
throws MappingException {
final JdbcEnvironment jdbcEnvironment = serviceRegistry.getService(JdbcEnvironment.class);
final Dialect dialect = jdbcEnvironment.getDialect();
this.identifierType = type;
boolean forceTableUse = ConfigurationHelper.getBoolean(FORCE_TBL_PARAM, params, false);
final QualifiedName sequenceName = determineSequenceName(params, dialect, jdbcEnvironment);
final int initialValue = determineInitialValue(params);
int incrementSize = determineIncrementSize(params);
final String optimizationStrategy = determineOptimizationStrategy(params, incrementSize);
incrementSize = determineAdjustedIncrementSize(optimizationStrategy, incrementSize);
if (dialect.supportsSequences() && !forceTableUse) {
if (!dialect.supportsPooledSequences()
&& OptimizerFactory.isPooledOptimizer(optimizationStrategy)) {
forceTableUse = true;
LOG.forcingTableUse();
}
}
this.databaseStructure =
buildDatabaseStructure(
type,
params,
jdbcEnvironment,
forceTableUse,
sequenceName,
initialValue,
incrementSize);
this.optimizer =
OptimizerFactory.buildOptimizer(
optimizationStrategy,
identifierType.getReturnedClass(),
incrementSize,
ConfigurationHelper.getInt(INITIAL_PARAM, params, -1));
this.databaseStructure.prepare(optimizer);
}
@Override
public void configure(
Type type, Properties params, Dialect dialect, ClassLoaderService classLoaderService)
throws MappingException {
this.identifierType = type;
boolean forceTableUse = ConfigurationHelper.getBoolean(FORCE_TBL_PARAM, params, false);
final ObjectName qualifiedSequenceName = determineSequenceName(params, dialect);
final String sequenceNameText = qualifiedSequenceName.toText(dialect);
final int initialValue = determineInitialValue(params);
int incrementSize = determineIncrementSize(params);
final String optimizationStrategy = determineOptimizationStrategy(params, incrementSize);
incrementSize = determineAdjustedIncrementSize(optimizationStrategy, incrementSize);
if (dialect.supportsSequences() && !forceTableUse) {
if (!dialect.supportsPooledSequences()
&& OptimizerFactory.isPooledOptimizer(optimizationStrategy)) {
forceTableUse = true;
LOG.forcingTableUse();
}
}
this.databaseStructure =
buildDatabaseStructure(
type,
params,
dialect,
forceTableUse,
qualifiedSequenceName,
initialValue,
incrementSize);
this.optimizer =
OptimizerFactory.buildOptimizer(
optimizationStrategy,
identifierType.getReturnedClass(),
incrementSize,
ConfigurationHelper.getInt(INITIAL_PARAM, params, -1),
classLoaderService);
this.databaseStructure.prepare(optimizer);
}
/**
* Determine the increment size to be applied. The exact implications of this value depends on the
* {@link #getOptimizer() optimizer} being used.
*
* <p>Called during {@link #configure configuration}.
*
* @param params The params supplied in the generator config (plus some standard useful extras).
* @return The increment size
*/
protected int determineIncrementSize(Properties params) {
return ConfigurationHelper.getInt(INCREMENT_PARAM, params, DEFAULT_INCREMENT_SIZE);
}
/**
* Determine the initial sequence value to use. This value is used when initializing the {@link
* #getDatabaseStructure() database structure} (i.e. sequence/table).
*
* <p>Called during {@link #configure configuration}.
*
* @param params The params supplied in the generator config (plus some standard useful extras).
* @return The initial value
*/
protected int determineInitialValue(Properties params) {
return ConfigurationHelper.getInt(INITIAL_PARAM, params, DEFAULT_INITIAL_VALUE);
}
public Settings buildSettings(Properties props, ServiceRegistry serviceRegistry) {
final boolean debugEnabled = LOG.isDebugEnabled();
final JdbcServices jdbcServices = serviceRegistry.getService(JdbcServices.class);
Settings settings = new Settings();
// SessionFactory name:
String sessionFactoryName = props.getProperty(AvailableSettings.SESSION_FACTORY_NAME);
settings.setSessionFactoryName(sessionFactoryName);
settings.setSessionFactoryNameAlsoJndiName(
ConfigurationHelper.getBoolean(
AvailableSettings.SESSION_FACTORY_NAME_IS_JNDI, props, true));
// JDBC and connection settings:
// Interrogate JDBC metadata
ExtractedDatabaseMetaData meta = jdbcServices.getExtractedMetaDataSupport();
settings.setDataDefinitionImplicitCommit(meta.doesDataDefinitionCauseTransactionCommit());
settings.setDataDefinitionInTransactionSupported(meta.supportsDataDefinitionInTransaction());
// use dialect default properties
final Properties properties = new Properties();
properties.putAll(jdbcServices.getDialect().getDefaultProperties());
properties.putAll(props);
// Transaction settings:
settings.setJtaPlatform(serviceRegistry.getService(JtaPlatform.class));
MultiTableBulkIdStrategy multiTableBulkIdStrategy =
serviceRegistry
.getService(StrategySelector.class)
.resolveStrategy(
MultiTableBulkIdStrategy.class,
properties.getProperty(AvailableSettings.HQL_BULK_ID_STRATEGY));
if (multiTableBulkIdStrategy == null) {
multiTableBulkIdStrategy =
jdbcServices.getDialect().supportsTemporaryTables()
? TemporaryTableBulkIdStrategy.INSTANCE
: new PersistentTableBulkIdStrategy();
}
settings.setMultiTableBulkIdStrategy(multiTableBulkIdStrategy);
boolean flushBeforeCompletion =
ConfigurationHelper.getBoolean(AvailableSettings.FLUSH_BEFORE_COMPLETION, properties);
if (debugEnabled) {
LOG.debugf(
"Automatic flush during beforeCompletion(): %s", enabledDisabled(flushBeforeCompletion));
}
settings.setFlushBeforeCompletionEnabled(flushBeforeCompletion);
boolean autoCloseSession =
ConfigurationHelper.getBoolean(AvailableSettings.AUTO_CLOSE_SESSION, properties);
if (debugEnabled) {
LOG.debugf(
"Automatic session close at end of transaction: %s", enabledDisabled(autoCloseSession));
}
settings.setAutoCloseSessionEnabled(autoCloseSession);
// JDBC and connection settings:
int batchSize =
ConfigurationHelper.getInt(AvailableSettings.STATEMENT_BATCH_SIZE, properties, 0);
if (!meta.supportsBatchUpdates()) {
batchSize = 0;
}
if (batchSize > 0 && debugEnabled) {
LOG.debugf("JDBC batch size: %s", batchSize);
}
settings.setJdbcBatchSize(batchSize);
boolean jdbcBatchVersionedData =
ConfigurationHelper.getBoolean(AvailableSettings.BATCH_VERSIONED_DATA, properties, false);
if (batchSize > 0 && debugEnabled) {
LOG.debugf(
"JDBC batch updates for versioned data: %s", enabledDisabled(jdbcBatchVersionedData));
}
settings.setJdbcBatchVersionedData(jdbcBatchVersionedData);
boolean useScrollableResultSets =
ConfigurationHelper.getBoolean(
AvailableSettings.USE_SCROLLABLE_RESULTSET,
properties,
meta.supportsScrollableResults());
if (debugEnabled) {
LOG.debugf("Scrollable result sets: %s", enabledDisabled(useScrollableResultSets));
}
settings.setScrollableResultSetsEnabled(useScrollableResultSets);
boolean wrapResultSets =
ConfigurationHelper.getBoolean(AvailableSettings.WRAP_RESULT_SETS, properties, false);
if (debugEnabled) {
LOG.debugf("Wrap result sets: %s", enabledDisabled(wrapResultSets));
}
settings.setWrapResultSetsEnabled(wrapResultSets);
boolean useGetGeneratedKeys =
ConfigurationHelper.getBoolean(
AvailableSettings.USE_GET_GENERATED_KEYS, properties, meta.supportsGetGeneratedKeys());
if (debugEnabled) {
LOG.debugf("JDBC3 getGeneratedKeys(): %s", enabledDisabled(useGetGeneratedKeys));
}
settings.setGetGeneratedKeysEnabled(useGetGeneratedKeys);
Integer statementFetchSize =
ConfigurationHelper.getInteger(AvailableSettings.STATEMENT_FETCH_SIZE, properties);
if (statementFetchSize != null && debugEnabled) {
LOG.debugf("JDBC result set fetch size: %s", statementFetchSize);
}
settings.setJdbcFetchSize(statementFetchSize);
MultiTenancyStrategy multiTenancyStrategy =
MultiTenancyStrategy.determineMultiTenancyStrategy(properties);
if (debugEnabled) {
LOG.debugf("multi-tenancy strategy : %s", multiTenancyStrategy);
}
settings.setMultiTenancyStrategy(multiTenancyStrategy);
String releaseModeName =
ConfigurationHelper.getString(AvailableSettings.RELEASE_CONNECTIONS, properties, "auto");
if (debugEnabled) {
LOG.debugf("Connection release mode: %s", releaseModeName);
}
ConnectionReleaseMode releaseMode;
if ("auto".equals(releaseModeName)) {
releaseMode = serviceRegistry.getService(TransactionFactory.class).getDefaultReleaseMode();
} else {
releaseMode = ConnectionReleaseMode.parse(releaseModeName);
if (releaseMode == ConnectionReleaseMode.AFTER_STATEMENT) {
// we need to make sure the underlying JDBC connection access supports aggressive release...
boolean supportsAgrressiveRelease =
multiTenancyStrategy.requiresMultiTenantConnectionProvider()
? serviceRegistry
.getService(MultiTenantConnectionProvider.class)
.supportsAggressiveRelease()
: serviceRegistry.getService(ConnectionProvider.class).supportsAggressiveRelease();
if (!supportsAgrressiveRelease) {
LOG.unsupportedAfterStatement();
releaseMode = ConnectionReleaseMode.AFTER_TRANSACTION;
}
}
}
settings.setConnectionReleaseMode(releaseMode);
final BatchFetchStyle batchFetchStyle =
BatchFetchStyle.interpret(properties.get(AvailableSettings.BATCH_FETCH_STYLE));
LOG.debugf("Using BatchFetchStyle : " + batchFetchStyle.name());
settings.setBatchFetchStyle(batchFetchStyle);
// SQL Generation settings:
String defaultSchema = properties.getProperty(AvailableSettings.DEFAULT_SCHEMA);
String defaultCatalog = properties.getProperty(AvailableSettings.DEFAULT_CATALOG);
if (defaultSchema != null && debugEnabled) {
LOG.debugf("Default schema: %s", defaultSchema);
}
if (defaultCatalog != null && debugEnabled) {
LOG.debugf("Default catalog: %s", defaultCatalog);
}
settings.setDefaultSchemaName(defaultSchema);
settings.setDefaultCatalogName(defaultCatalog);
Integer maxFetchDepth =
ConfigurationHelper.getInteger(AvailableSettings.MAX_FETCH_DEPTH, properties);
if (maxFetchDepth != null) {
LOG.debugf("Maximum outer join fetch depth: %s", maxFetchDepth);
}
settings.setMaximumFetchDepth(maxFetchDepth);
int batchFetchSize =
ConfigurationHelper.getInt(AvailableSettings.DEFAULT_BATCH_FETCH_SIZE, properties, 1);
if (debugEnabled) {
LOG.debugf("Default batch fetch size: %s", batchFetchSize);
}
settings.setDefaultBatchFetchSize(batchFetchSize);
boolean comments =
ConfigurationHelper.getBoolean(AvailableSettings.USE_SQL_COMMENTS, properties);
if (debugEnabled) {
LOG.debugf("Generate SQL with comments: %s", enabledDisabled(comments));
}
settings.setCommentsEnabled(comments);
boolean orderUpdates =
ConfigurationHelper.getBoolean(AvailableSettings.ORDER_UPDATES, properties);
if (debugEnabled) {
LOG.debugf("Order SQL updates by primary key: %s", enabledDisabled(orderUpdates));
}
settings.setOrderUpdatesEnabled(orderUpdates);
boolean orderInserts =
ConfigurationHelper.getBoolean(AvailableSettings.ORDER_INSERTS, properties);
if (debugEnabled) {
LOG.debugf("Order SQL inserts for batching: %s", enabledDisabled(orderInserts));
}
settings.setOrderInsertsEnabled(orderInserts);
String defaultNullPrecedence =
ConfigurationHelper.getString(
AvailableSettings.DEFAULT_NULL_ORDERING, properties, "none", "first", "last");
if (debugEnabled) {
LOG.debugf("Default null ordering: %s", defaultNullPrecedence);
}
settings.setDefaultNullPrecedence(NullPrecedence.parse(defaultNullPrecedence));
// Query parser settings:
settings.setQueryTranslatorFactory(createQueryTranslatorFactory(properties, serviceRegistry));
Map querySubstitutions =
ConfigurationHelper.toMap(
AvailableSettings.QUERY_SUBSTITUTIONS, " ,=;:\n\t\r\f", properties);
if (debugEnabled) {
LOG.debugf("Query language substitutions: %s", querySubstitutions);
}
settings.setQuerySubstitutions(querySubstitutions);
boolean jpaqlCompliance =
ConfigurationHelper.getBoolean(
AvailableSettings.JPAQL_STRICT_COMPLIANCE, properties, false);
if (debugEnabled) {
LOG.debugf("JPA-QL strict compliance: %s", enabledDisabled(jpaqlCompliance));
}
settings.setStrictJPAQLCompliance(jpaqlCompliance);
// Second-level / query cache:
boolean useSecondLevelCache =
ConfigurationHelper.getBoolean(AvailableSettings.USE_SECOND_LEVEL_CACHE, properties, true);
if (debugEnabled) {
LOG.debugf("Second-level cache: %s", enabledDisabled(useSecondLevelCache));
}
settings.setSecondLevelCacheEnabled(useSecondLevelCache);
boolean useQueryCache =
ConfigurationHelper.getBoolean(AvailableSettings.USE_QUERY_CACHE, properties);
if (debugEnabled) {
LOG.debugf("Query cache: %s", enabledDisabled(useQueryCache));
}
settings.setQueryCacheEnabled(useQueryCache);
if (useQueryCache) {
settings.setQueryCacheFactory(createQueryCacheFactory(properties, serviceRegistry));
}
// The cache provider is needed when we either have second-level cache enabled
// or query cache enabled. Note that useSecondLevelCache is enabled by default
settings.setRegionFactory(
createRegionFactory(properties, (useSecondLevelCache || useQueryCache), serviceRegistry));
boolean useMinimalPuts =
ConfigurationHelper.getBoolean(
AvailableSettings.USE_MINIMAL_PUTS,
properties,
settings.getRegionFactory().isMinimalPutsEnabledByDefault());
if (debugEnabled) {
LOG.debugf("Optimize cache for minimal puts: %s", enabledDisabled(useMinimalPuts));
}
settings.setMinimalPutsEnabled(useMinimalPuts);
String prefix = properties.getProperty(AvailableSettings.CACHE_REGION_PREFIX);
if (StringHelper.isEmpty(prefix)) {
prefix = null;
}
if (prefix != null && debugEnabled) {
LOG.debugf("Cache region prefix: %s", prefix);
}
settings.setCacheRegionPrefix(prefix);
boolean useStructuredCacheEntries =
ConfigurationHelper.getBoolean(AvailableSettings.USE_STRUCTURED_CACHE, properties, false);
if (debugEnabled) {
LOG.debugf(
"Structured second-level cache entries: %s", enabledDisabled(useStructuredCacheEntries));
}
settings.setStructuredCacheEntriesEnabled(useStructuredCacheEntries);
boolean useDirectReferenceCacheEntries =
ConfigurationHelper.getBoolean(
AvailableSettings.USE_DIRECT_REFERENCE_CACHE_ENTRIES, properties, false);
if (debugEnabled) {
LOG.debugf(
"Second-level cache direct-reference entries: %s",
enabledDisabled(useDirectReferenceCacheEntries));
}
settings.setDirectReferenceCacheEntriesEnabled(useDirectReferenceCacheEntries);
// Statistics and logging:
boolean useStatistics =
ConfigurationHelper.getBoolean(AvailableSettings.GENERATE_STATISTICS, properties);
if (debugEnabled) {
LOG.debugf("Statistics: %s", enabledDisabled(useStatistics));
}
settings.setStatisticsEnabled(useStatistics);
boolean useIdentifierRollback =
ConfigurationHelper.getBoolean(AvailableSettings.USE_IDENTIFIER_ROLLBACK, properties);
if (debugEnabled) {
LOG.debugf(
"Deleted entity synthetic identifier rollback: %s",
enabledDisabled(useIdentifierRollback));
}
settings.setIdentifierRollbackEnabled(useIdentifierRollback);
// Schema export:
String autoSchemaExport = properties.getProperty(AvailableSettings.HBM2DDL_AUTO);
if ("validate".equals(autoSchemaExport)) {
settings.setAutoValidateSchema(true);
}
if ("update".equals(autoSchemaExport)) {
settings.setAutoUpdateSchema(true);
}
if ("create".equals(autoSchemaExport)) {
settings.setAutoCreateSchema(true);
}
if ("create-drop".equals(autoSchemaExport)) {
settings.setAutoCreateSchema(true);
settings.setAutoDropSchema(true);
}
settings.setImportFiles(properties.getProperty(AvailableSettings.HBM2DDL_IMPORT_FILES));
EntityMode defaultEntityMode =
EntityMode.parse(properties.getProperty(AvailableSettings.DEFAULT_ENTITY_MODE));
if (debugEnabled) {
LOG.debugf("Default entity-mode: %s", defaultEntityMode);
}
settings.setDefaultEntityMode(defaultEntityMode);
boolean namedQueryChecking =
ConfigurationHelper.getBoolean(AvailableSettings.QUERY_STARTUP_CHECKING, properties, true);
if (debugEnabled) {
LOG.debugf("Named query checking : %s", enabledDisabled(namedQueryChecking));
}
settings.setNamedQueryStartupCheckingEnabled(namedQueryChecking);
boolean checkNullability =
ConfigurationHelper.getBoolean(AvailableSettings.CHECK_NULLABILITY, properties, true);
if (debugEnabled) {
LOG.debugf(
"Check Nullability in Core (should be disabled when Bean Validation is on): %s",
enabledDisabled(checkNullability));
}
settings.setCheckNullability(checkNullability);
// TODO: Does EntityTuplizerFactory really need to be configurable? revisit for HHH-6383
settings.setEntityTuplizerFactory(new EntityTuplizerFactory());
// String provider = properties.getProperty( AvailableSettings.BYTECODE_PROVIDER );
// log.info( "Bytecode provider name : " + provider );
// BytecodeProvider bytecodeProvider = buildBytecodeProvider( provider );
// settings.setBytecodeProvider( bytecodeProvider );
boolean initializeLazyStateOutsideTransactionsEnabled =
ConfigurationHelper.getBoolean(
AvailableSettings.ENABLE_LAZY_LOAD_NO_TRANS, properties, false);
if (debugEnabled) {
LOG.debugf(
"Allow initialization of lazy state outside session : : %s",
enabledDisabled(initializeLazyStateOutsideTransactionsEnabled));
}
settings.setInitializeLazyStateOutsideTransactions(
initializeLazyStateOutsideTransactionsEnabled);
return settings;
}