/**
   * Determine the name of the sequence (or table if this resolves to a physical table) to use.
   *
   * <p>Called during {@link #configure configuration}.
   *
   * @param params The params supplied in the generator config (plus some standard useful extras).
   * @param dialect The dialect in effect
   * @param jdbcEnv The JdbcEnvironment
   * @return The sequence name
   */
  @SuppressWarnings("UnusedParameters")
  protected QualifiedName determineSequenceName(
      Properties params, Dialect dialect, JdbcEnvironment jdbcEnv) {
    final String sequencePerEntitySuffix =
        ConfigurationHelper.getString(
            CONFIG_SEQUENCE_PER_ENTITY_SUFFIX, params, DEF_SEQUENCE_SUFFIX);
    // JPA_ENTITY_NAME value honors <class ... entity-name="..."> (HBM) and @Entity#name (JPA)
    // overrides.
    final String defaultSequenceName =
        ConfigurationHelper.getBoolean(CONFIG_PREFER_SEQUENCE_PER_ENTITY, params, false)
            ? params.getProperty(JPA_ENTITY_NAME) + sequencePerEntitySuffix
            : DEF_SEQUENCE_NAME;

    final String sequenceName =
        ConfigurationHelper.getString(SEQUENCE_PARAM, params, defaultSequenceName);
    if (sequenceName.contains(".")) {
      return QualifiedNameParser.INSTANCE.parse(sequenceName);
    } else {
      // todo : need to incorporate implicit catalog and schema names
      final Identifier catalog =
          jdbcEnv
              .getIdentifierHelper()
              .toIdentifier(ConfigurationHelper.getString(CATALOG, params));
      final Identifier schema =
          jdbcEnv.getIdentifierHelper().toIdentifier(ConfigurationHelper.getString(SCHEMA, params));
      return new QualifiedNameParser.NameParts(
          catalog, schema, jdbcEnv.getIdentifierHelper().toIdentifier(sequenceName));
    }
  }
Ejemplo n.º 2
0
  @Configuration
  public Option[] config() throws Exception {
    final Properties paxExamEnvironment = loadPaxExamEnvironmentProperties();

    final boolean debug =
        ConfigurationHelper.getBoolean(
            "org.hibernate.testing.osgi.paxExam.debug", Environment.getProperties(), DEBUG);

    return options(
        when(debug).useOptions(debugConfiguration("5005", true)),
        karafDistributionConfiguration()
            .frameworkUrl(
                paxExamEnvironment.getProperty("org.ops4j.pax.exam.container.karaf.distroUrl"))
            .karafVersion(
                paxExamEnvironment.getProperty("org.ops4j.pax.exam.container.karaf.version"))
            .name("Apache Karaf")
            .unpackDirectory(
                new File(
                    paxExamEnvironment.getProperty("org.ops4j.pax.exam.container.karaf.unpackDir")))
            .useDeployFolder(false),
        editConfigurationFileExtend(
            "etc/org.ops4j.pax.url.mvn.cfg",
            "org.ops4j.pax.url.mvn.repositories",
            "https://repository.jboss.org/nexus/content/groups/public/"),
        configureConsole().ignoreLocalConsole().ignoreRemoteShell(),
        when(debug).useOptions(keepRuntimeFolder()),
        logLevel(LogLevelOption.LogLevel.INFO),
        features(featureXmlUrl(paxExamEnvironment), "hibernate-orm"),
        features(testingFeatureXmlUrl(), "hibernate-osgi-testing"));
  }
Ejemplo n.º 3
0
  @Override
  public void setParameterValues(Properties parameters) {
    final ParameterType reader = (ParameterType) parameters.get(PARAMETER_TYPE);

    // IMPL NOTE : be protective about not setting enumValueMapper (i.e. calling
    // treatAsNamed/treatAsOrdinal)
    // in cases where we do not have enough information.  In such cases we do additional checks
    // as part of nullSafeGet/nullSafeSet to query against the JDBC metadata to make the
    // determination.

    if (reader != null) {
      enumClass = reader.getReturnedClass().asSubclass(Enum.class);

      final boolean isOrdinal;
      final javax.persistence.EnumType enumType = getEnumType(reader);
      if (enumType == null) {
        isOrdinal = true;
      } else if (javax.persistence.EnumType.ORDINAL.equals(enumType)) {
        isOrdinal = true;
      } else if (javax.persistence.EnumType.STRING.equals(enumType)) {
        isOrdinal = false;
      } else {
        throw new AssertionFailure("Unknown EnumType: " + enumType);
      }

      if (isOrdinal) {
        treatAsOrdinal();
      } else {
        treatAsNamed();
      }
      sqlType = enumValueMapper.getSqlType();
    } else {
      String enumClassName = (String) parameters.get(ENUM);
      try {
        enumClass =
            ReflectHelper.classForName(enumClassName, this.getClass()).asSubclass(Enum.class);
      } catch (ClassNotFoundException exception) {
        throw new HibernateException("Enum class not found", exception);
      }

      final Object useNamedSetting = parameters.get(NAMED);
      if (useNamedSetting != null) {
        final boolean useNamed = ConfigurationHelper.getBoolean(NAMED, parameters);
        if (useNamed) {
          treatAsNamed();
        } else {
          treatAsOrdinal();
        }
        sqlType = enumValueMapper.getSqlType();
      }
    }

    final String type = (String) parameters.get(TYPE);
    if (type != null) {
      sqlType = Integer.decode(type);
    }
  }
 /**
  * Determine the optimizer to use.
  *
  * <p>Called during {@link #configure configuration}.
  *
  * @param params The params supplied in the generator config (plus some standard useful extras).
  * @param incrementSize The {@link #determineIncrementSize determined increment size}
  * @return The optimizer strategy (name)
  */
 protected String determineOptimizationStrategy(Properties params, int incrementSize) {
   // if the increment size is greater than one, we prefer pooled optimization; but we first
   // need to see if the user prefers POOL or POOL_LO...
   final String defaultPooledOptimizerStrategy =
       ConfigurationHelper.getBoolean(Environment.PREFER_POOLED_VALUES_LO, params, false)
           ? StandardOptimizerDescriptor.POOLED_LO.getExternalName()
           : StandardOptimizerDescriptor.POOLED.getExternalName();
   final String defaultOptimizerStrategy =
       incrementSize <= 1
           ? StandardOptimizerDescriptor.NONE.getExternalName()
           : defaultPooledOptimizerStrategy;
   return ConfigurationHelper.getString(OPT_PARAM, params, defaultOptimizerStrategy);
 }
Ejemplo n.º 5
0
  /**
   * Pool configuration.
   *
   * @param props
   * @throws HibernateException
   */
  public void configure(Properties props) throws HibernateException {
    try {
      this.config = new BoneCPConfig(props);

      // old hibernate config
      String url = props.getProperty(CONFIG_CONNECTION_URL);
      String username = props.getProperty(CONFIG_CONNECTION_USERNAME);
      String password = props.getProperty(CONFIG_CONNECTION_PASSWORD);
      String driver = props.getProperty(CONFIG_CONNECTION_DRIVER_CLASS);
      if (url == null) {
        url = props.getProperty(CONFIG_CONNECTION_URL_ALTERNATE);
      }
      if (username == null) {
        username = props.getProperty(CONFIG_CONNECTION_USERNAME_ALTERNATE);
      }
      if (password == null) {
        password = props.getProperty(CONFIG_CONNECTION_PASSWORD_ALTERNATE);
      }
      if (driver == null) {
        driver = props.getProperty(CONFIG_CONNECTION_DRIVER_CLASS_ALTERNATE);
      }

      if (url != null) {
        this.config.setJdbcUrl(url);
      }
      if (username != null) {
        this.config.setUsername(username);
      }
      if (password != null) {
        this.config.setPassword(password);
      }

      // Remember Isolation level
      this.isolation = ConfigurationHelper.getInteger(AvailableSettings.ISOLATION, props);
      this.autocommit = ConfigurationHelper.getBoolean(AvailableSettings.AUTOCOMMIT, props);

      logger.debug(this.config.toString());

      if (driver != null && !driver.trim().equals("")) {
        loadClass(driver);
      }
      if (this.config.getConnectionHookClassName() != null) {
        Object hookClass = loadClass(this.config.getConnectionHookClassName()).newInstance();
        this.config.setConnectionHook((ConnectionHook) hookClass);
      }
      // create the connection pool
      this.pool = createPool(this.config);
    } catch (Exception e) {
      throw new HibernateException(e);
    }
  }
  @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 name of the sequence (or table if this resolves to a physical table) to use.
   *
   * <p>Called during {@link #configure configuration}.
   *
   * @param params The params supplied in the generator config (plus some standard useful extras).
   * @param dialect The dialect in effect
   * @return The sequence name
   */
  protected ObjectName determineSequenceName(Properties params, Dialect dialect) {
    String sequencePerEntitySuffix =
        ConfigurationHelper.getString(
            CONFIG_SEQUENCE_PER_ENTITY_SUFFIX, params, DEF_SEQUENCE_SUFFIX);
    // JPA_ENTITY_NAME value honors <class ... entity-name="..."> (HBM) and @Entity#name (JPA)
    // overrides.
    String sequenceName =
        ConfigurationHelper.getBoolean(CONFIG_PREFER_SEQUENCE_PER_ENTITY, params, false)
            ? params.getProperty(JPA_ENTITY_NAME) + sequencePerEntitySuffix
            : DEF_SEQUENCE_NAME;
    final ObjectNameNormalizer normalizer =
        (ObjectNameNormalizer) params.get(IDENTIFIER_NORMALIZER);
    sequenceName =
        normalizer.normalizeIdentifierQuoting(
            ConfigurationHelper.getString(SEQUENCE_PARAM, params, sequenceName));
    if (sequenceName.indexOf('.') < 0) {
      final String schemaName = normalizer.normalizeIdentifierQuoting(params.getProperty(SCHEMA));
      final String catalogName = normalizer.normalizeIdentifierQuoting(params.getProperty(CATALOG));

      return new ObjectName(catalogName, schemaName, sequenceName);
    } else {
      return ObjectName.parse(sequenceName);
    }
  }
Ejemplo n.º 9
0
 public static boolean isExplicitVersionCheckEnabled(Properties props) {
   return ConfigurationHelper.getBoolean(CacheEnvironment.EXPLICIT_VERSION_CHECK, props, false);
 }
Ejemplo n.º 10
0
 public static boolean shutdownOnStop(Properties props, boolean defaultValue) {
   return ConfigurationHelper.getBoolean(CacheEnvironment.SHUTDOWN_ON_STOP, props, defaultValue);
 }
Ejemplo n.º 11
0
 public static boolean isNativeClient(Properties props) {
   return ConfigurationHelper.getBoolean(CacheEnvironment.USE_NATIVE_CLIENT, props, false);
 }
Ejemplo n.º 12
0
  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;
  }