Example usage for org.apache.commons.dbcp2 BasicDataSource setConnectionInitSqls

List of usage examples for org.apache.commons.dbcp2 BasicDataSource setConnectionInitSqls

Introduction

In this page you can find the example usage for org.apache.commons.dbcp2 BasicDataSource setConnectionInitSqls.

Prototype

public void setConnectionInitSqls(Collection<String> connectionInitSqls) 

Source Link

Document

Sets the list of SQL statements to be executed when a physical connection is first created.

Usage

From source file:io.druid.metadata.storage.mysql.MySQLConnector.java

@Inject
public MySQLConnector(Supplier<MetadataStorageConnectorConfig> config,
        Supplier<MetadataStorageTablesConfig> dbTables) {
    super(config, dbTables);

    final BasicDataSource datasource = getDatasource();
    // MySQL driver is classloader isolated as part of the extension
    // so we need to help JDBC find the driver
    datasource.setDriverClassLoader(getClass().getClassLoader());
    datasource.setDriverClassName("com.mysql.jdbc.Driver");

    // use double-quotes for quoting columns, so we can write SQL that works with most databases
    datasource.setConnectionInitSqls(ImmutableList.of("SET sql_mode='ANSI_QUOTES'"));

    this.dbi = new DBI(datasource);

    log.info("Configured MySQL as metadata storage");
}

From source file:annis.administration.AdministrationDao.java

private BasicDataSource createDataSource(String host, String port, String database, String user,
        String password, boolean useSSL, String schema) {

    String url = "jdbc:postgresql://" + host + ":" + port + "/" + database;

    // DriverManagerDataSource is deprecated
    // return new DriverManagerDataSource("org.postgresql.Driver", url, user, password);
    BasicDataSource result = new BasicDataSource();
    result.setUrl(url);/*from   ww  w.j  a  v  a2s . c o  m*/
    if (useSSL) {
        result.setConnectionProperties("ssl=true");
    }
    result.setUsername(user);
    result.setPassword(password);
    result.setValidationQuery("SELECT 1;");
    result.setAccessToUnderlyingConnectionAllowed(true);
    if (schema == null) {
        schema = "public";
    }
    result.setConnectionInitSqls(Arrays.asList("SET search_path TO \"$user\"," + schema));

    result.setDriverClassName("org.postgresql.Driver");

    return result;
}

From source file:org.apache.druid.metadata.storage.mysql.MySQLConnector.java

@Inject
public MySQLConnector(Supplier<MetadataStorageConnectorConfig> config,
        Supplier<MetadataStorageTablesConfig> dbTables, MySQLConnectorConfig connectorConfig) {
    super(config, dbTables);

    final BasicDataSource datasource = getDatasource();
    // MySQL driver is classloader isolated as part of the extension
    // so we need to help JDBC find the driver
    datasource.setDriverClassLoader(getClass().getClassLoader());
    datasource.setDriverClassName("com.mysql.jdbc.Driver");
    datasource.addConnectionProperty("useSSL", String.valueOf(connectorConfig.isUseSSL()));
    if (connectorConfig.isUseSSL()) {
        log.info("SSL is enabled on this MySQL connection. ");

        datasource.addConnectionProperty("verifyServerCertificate",
                String.valueOf(connectorConfig.isVerifyServerCertificate()));
        if (connectorConfig.isVerifyServerCertificate()) {
            log.info("Server certificate verification is enabled. ");

            if (connectorConfig.getTrustCertificateKeyStoreUrl() != null) {
                datasource.addConnectionProperty("trustCertificateKeyStoreUrl",
                        new File(connectorConfig.getTrustCertificateKeyStoreUrl()).toURI().toString());
            }// www  .  java  2 s  .  c  o  m
            if (connectorConfig.getTrustCertificateKeyStoreType() != null) {
                datasource.addConnectionProperty("trustCertificateKeyStoreType",
                        connectorConfig.getTrustCertificateKeyStoreType());
            }
            if (connectorConfig.getTrustCertificateKeyStorePassword() == null) {
                log.warn(
                        "Trust store password is empty. Ensure that the trust store has been configured with an empty password.");
            } else {
                datasource.addConnectionProperty("trustCertificateKeyStorePassword",
                        connectorConfig.getTrustCertificateKeyStorePassword());
            }
        }
        if (connectorConfig.getClientCertificateKeyStoreUrl() != null) {
            datasource.addConnectionProperty("clientCertificateKeyStoreUrl",
                    new File(connectorConfig.getClientCertificateKeyStoreUrl()).toURI().toString());
        }
        if (connectorConfig.getClientCertificateKeyStoreType() != null) {
            datasource.addConnectionProperty("clientCertificateKeyStoreType",
                    connectorConfig.getClientCertificateKeyStoreType());
        }
        if (connectorConfig.getClientCertificateKeyStorePassword() != null) {
            datasource.addConnectionProperty("clientCertificateKeyStorePassword",
                    connectorConfig.getClientCertificateKeyStorePassword());
        }
        Joiner joiner = Joiner.on(",").skipNulls();
        if (connectorConfig.getEnabledSSLCipherSuites() != null) {
            datasource.addConnectionProperty("enabledSSLCipherSuites",
                    joiner.join(connectorConfig.getEnabledSSLCipherSuites()));
        }
        if (connectorConfig.getEnabledTLSProtocols() != null) {
            datasource.addConnectionProperty("enabledTLSProtocols",
                    joiner.join(connectorConfig.getEnabledTLSProtocols()));
        }
    }

    // use double-quotes for quoting columns, so we can write SQL that works with most databases
    datasource.setConnectionInitSqls(ImmutableList.of("SET sql_mode='ANSI_QUOTES'"));

    this.dbi = new DBI(datasource);

    log.info("Configured MySQL as metadata storage");
}

From source file:org.everit.osgi.jdbc.commons.dbcp.internal.Util.java

public static void applyPropertiesOnBasicDataSource(final BasicDataSource basicDataSource,
        final Map<String, Object> componentProperties) {

    setPropertyIfNotNull(basicDataSource, componentProperties,
            DSFConstants.PROP_ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED, boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_DEFAULT_AUTO_COMMIT,
            Boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_DEFAULT_CATALOG, String.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_DEFAULT_READ_ONLY,
            Boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_DEFAULT_QUERY_TIMEOUT,
            Integer.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_INITIAL_SIZE, int.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_LOG_ABANDONED, boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_MAX_TOTAL, int.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_MAX_IDLE, int.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_MAX_OPEN_PREPARED_STATEMENTS,
            int.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_MAX_WAIT_MILLIS, long.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_MIN_EVICTABLE_IDLE_TIME_MILLIS,
            long.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_MIN_IDLE, int.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_NUM_TESTS_PER_EVICTION_RUN,
            int.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_POOL_PREPARED_STATEMENTS,
            boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_REMOVE_ABANDONED_ON_BORROW,
            boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties,
            DSFConstants.PROP_REMOVE_ABANDONED_ON_MAINTENANCE, boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_REMOVE_ABANDONED_TIMEOUT,
            int.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_TEST_ON_BORROW, boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_TEST_ON_RETURN, boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_TEST_WHILE_IDLE,
            boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties,
            DSFConstants.PROP_TIME_BETWEEN_EVICTION_RUNS_MILLIS, long.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_VALIDATION_QUERY,
            String.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_VALIDATION_QUERY_TIMEOUT,
            int.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_LIFO, boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_CACHE_STATE, boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_TEST_ON_CREATE, boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties,
            DSFConstants.PROP_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS, long.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_MAX_CONN_LIFETIME_MILLIS,
            long.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_JMX_NAME, String.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_ENABLE_AUTO_COMMIT_ON_RETURN,
            boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_ROLLBACK_ON_RETURN,
            boolean.class);

    setPropertyIfNotNull(basicDataSource, componentProperties, DSFConstants.PROP_ABANDONED_USAGE_TRACKING,
            boolean.class);

    Object connectionInitSqlsObject = componentProperties.get(DSFConstants.PROP_CONNECTION_INIT_SQLS);
    if (connectionInitSqlsObject != null) {
        if (!(connectionInitSqlsObject instanceof Collection)) {
            throw new RuntimeException("Expected type of " + DSFConstants.PROP_CONNECTION_INIT_SQLS
                    + "' is Collection but " + connectionInitSqlsObject.getClass() + " provided");
        }/* w  w  w. ja v  a  2  s.c o  m*/

        @SuppressWarnings("unchecked")
        Collection<String> connectionInitSqls = (Collection<String>) connectionInitSqlsObject;
        basicDataSource.setConnectionInitSqls(connectionInitSqls);
    }

    Object transactionIsolationObject = componentProperties
            .get(DSFConstants.PROP_DEFAULT_TRANSACTION_ISOLATION);
    if (transactionIsolationObject != null) {
        if (DSFConstants.VALUE_READ_COMMITED.equals(transactionIsolationObject)) {
            basicDataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
        } else if (DSFConstants.VALUE_READ_UNCOMMITTED.equals(transactionIsolationObject)) {
            basicDataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
        } else if (DSFConstants.VALUE_REPEATABLE_READ.equals(transactionIsolationObject)) {
            basicDataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
        } else if (DSFConstants.VALUE_SERIALIZABLE.equals(transactionIsolationObject)) {
            basicDataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
        } else if (DSFConstants.VALUE_TRANSACTION_NONE.equals(transactionIsolationObject)) {
            basicDataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_NONE);
        } else {
            throw new RuntimeException("Unknown value '" + transactionIsolationObject
                    + "' for the property key '" + DSFConstants.PROP_DEFAULT_TRANSACTION_ISOLATION
                    + " during datasource configuration.");
        }

    }
}

From source file:org.everit.persistence.jdbc.commons.dbcp.ecm.internal.Util.java

private static void applyConnectionInitSqlsOnBasicDataSource(final BasicDataSource basicDataSource,
        final Object connectionInitSqlsObject) {
    if (connectionInitSqlsObject != null) {
        if (!(connectionInitSqlsObject instanceof String[])) {
            throw new RuntimeException(
                    "Expected type of " + DSFConstants.ATTR_CONNECTION_INIT_SQLS + "' is not String[].");
        }//from   ww  w  . j a  va 2  s.  c o m

        Collection<String> connectionInitSqls = Arrays.asList((String[]) connectionInitSqlsObject);
        basicDataSource.setConnectionInitSqls(connectionInitSqls);
    }
}

From source file:org.lib4j.dbcp.DataSources.java

/**
 * Create a <code>BasicDataSource</code> given a dbcp JAXB binding.
 *
 * @param dbcp JAXB dbcp binding./*  w  w  w. j  a v  a2 s. c  o  m*/
 * @param driverClassLoader Class loader to be used to load the JDBC driver.
 * @return the <code>BasicDataSource</code> instance.
 * @throws SQLException If a database access error occurs.
 */
public static BasicDataSource createDataSource(final Dbcp dbcp, final ClassLoader driverClassLoader)
        throws SQLException {
    final BasicDataSource dataSource = new BasicDataSource();

    final Dbcp.Jdbc jdbc = dbcp.getJdbc();
    dataSource.setDriverClassName(jdbc.getDriverClassName());
    dataSource.setDriverClassLoader(driverClassLoader);

    dataSource.setUrl(jdbc.getUrl());

    dataSource.setUsername(jdbc.getUsername());
    dataSource.setPassword(jdbc.getPassword());

    final Dbcp.Default _default = dbcp.getDefault();
    if (_default != null && _default.getCatalog() != null)
        dataSource.setDefaultCatalog(_default.getCatalog());

    dataSource.setDefaultAutoCommit(
            _default == null || _default.getAutoCommit() == null || _default.getAutoCommit());
    dataSource.setDefaultReadOnly(_default != null && _default.getReadOnly() != null && _default.getReadOnly());
    if (_default != null && _default.getQueryTimeout() != null)
        dataSource.setDefaultQueryTimeout(_default.getQueryTimeout());

    if (_default != null && _default.getTransactionIsolation() != null) {
        if ("NONE".equals(_default.getTransactionIsolation()))
            dataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_NONE);
        else if ("READ_COMMITTED".equals(_default.getTransactionIsolation()))
            dataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
        else if ("READ_UNCOMMITTED".equals(_default.getTransactionIsolation()))
            dataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
        else if ("REPEATABLE_READ".equals(_default.getTransactionIsolation()))
            dataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
        else if ("SERIALIZABLE".equals(_default.getTransactionIsolation()))
            dataSource.setDefaultTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
        else
            throw new UnsupportedOperationException(
                    "Unsupported transaction isolation: " + _default.getTransactionIsolation());
    }

    final Dbcp.Connection connection = dbcp.getConnection();
    if (connection != null) {
        if (connection.getProperties() != null)
            for (final Dbcp.Connection.Properties.Property property : connection.getProperties().getProperty())
                if (property.getName() != null && property.getValue() != null)
                    dataSource.addConnectionProperty(property.getName(), property.getValue());

        if (connection.getInitSqls() != null) {
            final List<String> initSqls = new ArrayList<>();
            for (final String initSql : connection.getInitSqls().getInitSql())
                initSqls.add(initSql);

            dataSource.setConnectionInitSqls(initSqls);
        }
    }

    final Dbcp.Size size = dbcp.getSize();
    dataSource.setInitialSize(size == null || size.getInitialSize() == null ? 0 : size.getInitialSize());
    dataSource.setMaxTotal(size == null || size.getMaxTotal() == null ? 8
            : INDEFINITE.equals(size.getMaxTotal()) ? -1 : Integer.parseInt(size.getMaxTotal()));
    dataSource.setMaxIdle(size == null || size.getMaxIdle() == null ? 8
            : INDEFINITE.equals(size.getMaxIdle()) ? -1 : Integer.parseInt(size.getMaxIdle()));
    dataSource.setMinIdle(size == null || size.getMinIdle() == null ? 9 : size.getMinIdle());
    if (size == null || size.getMaxOpenPreparedStatements() == null
            || INDEFINITE.equals(size.getMaxOpenPreparedStatements())) {
        dataSource.setPoolPreparedStatements(false);
    } else {
        dataSource.setPoolPreparedStatements(true);
        dataSource.setMaxOpenPreparedStatements(Integer.parseInt(size.getMaxOpenPreparedStatements()));
    }

    final Dbcp.Pool pool = dbcp.getPool();
    if (pool == null || pool.getQueue() == null || "lifo".equals(pool.getQueue()))
        dataSource.setLifo(true);
    else if ("fifo".equals(pool.getQueue()))
        dataSource.setLifo(false);
    else
        throw new UnsupportedOperationException("Unsupported queue spec: " + pool.getQueue());

    dataSource.setCacheState(pool != null && pool.getCacheState() != null && pool.getCacheState());
    dataSource.setMaxWaitMillis(
            pool == null || pool.getMaxWait() != null || INDEFINITE.equals(pool.getMaxWait()) ? -1
                    : Long.parseLong(pool.getMaxWait()));
    dataSource.setMaxConnLifetimeMillis(pool == null || pool.getMaxConnectionLifetime() == null
            || INDEFINITE.equals(pool.getMaxConnectionLifetime()) ? 0
                    : Long.parseLong(pool.getMaxConnectionLifetime()));
    dataSource.setEnableAutoCommitOnReturn(_default == null || pool.getEnableAutoCommitOnReturn() == null
            || pool.getEnableAutoCommitOnReturn());
    dataSource.setRollbackOnReturn(
            pool == null || pool.getRollbackOnReturn() == null || pool.getRollbackOnReturn());
    if (pool != null && pool.getRemoveAbandoned() != null) {
        if ("borrow".equals(pool.getRemoveAbandoned().getOn()))
            dataSource.setRemoveAbandonedOnBorrow(true);
        else if ("maintenance".equals(pool.getRemoveAbandoned().getOn()))
            dataSource.setRemoveAbandonedOnMaintenance(true);
        else
            throw new UnsupportedOperationException(
                    "Unsupported remove abandoned spec: " + pool.getRemoveAbandoned().getOn());

        dataSource.setRemoveAbandonedTimeout(pool.getRemoveAbandoned().getTimeout());
    }

    dataSource.setAbandonedUsageTracking(
            pool != null && pool.getAbandonedUsageTracking() != null && pool.getAbandonedUsageTracking());
    dataSource.setAccessToUnderlyingConnectionAllowed(
            pool != null && pool.getAllowAccessToUnderlyingConnection() != null
                    && pool.getAllowAccessToUnderlyingConnection());

    final Dbcp.Pool.Eviction evictor = pool != null && pool.getEviction() != null ? pool.getEviction() : null;
    if (evictor != null) {
        dataSource.setTimeBetweenEvictionRunsMillis(evictor.getTimeBetweenRuns());
        dataSource.setNumTestsPerEvictionRun(evictor.getNumTestsPerRun());
        dataSource.setMinEvictableIdleTimeMillis(
                evictor.getMinIdleTime() == null ? 1800000 : evictor.getMinIdleTime());
        dataSource.setSoftMinEvictableIdleTimeMillis(
                evictor.getSoftMinIdleTime() == null || INDEFINITE.equals(evictor.getSoftMinIdleTime()) ? -1
                        : Long.parseLong(evictor.getSoftMinIdleTime()));
        if (evictor.getPolicyClassName() != null)
            dataSource.setEvictionPolicyClassName(evictor.getPolicyClassName());
    }

    final Dbcp.Validation validation = dbcp.getValidation();
    if (validation != null && validation.getQuery() != null)
        dataSource.setValidationQuery(validation.getQuery());

    dataSource.setTestOnBorrow(
            validation == null || validation.getTestOnBorrow() == null || validation.getTestOnBorrow());
    dataSource.setTestOnReturn(
            validation != null && validation.getTestOnReturn() != null && validation.getTestOnReturn());
    dataSource.setTestWhileIdle(
            validation != null && validation.getTestWhileIdle() != null && validation.getTestWhileIdle());
    if (validation != null && validation.getFastFail() != null) {
        dataSource.setFastFailValidation(true);
        if (validation.getFastFail().getDisconnectionSqlCodes() != null)
            dataSource.setDisconnectionSqlCodes(
                    Arrays.asList(validation.getFastFail().getDisconnectionSqlCodes().split(" ")));
    }

    final Dbcp.Logging logging = dbcp.getLogging();
    if (logging != null) {
        final Logger logger = LoggerFactory.getLogger(DataSources.class);
        final LoggerPrintWriter loggerPrintWriter = new LoggerPrintWriter(logger,
                Level.valueOf(logging.getLevel().toString()));
        dataSource.setLogWriter(loggerPrintWriter);
        dataSource.setLogExpiredConnections(logging.isLogExpiredConnections());
        if (logging.isLogAbandoned()) {
            dataSource.setAbandonedLogWriter(loggerPrintWriter);
            dataSource.setLogAbandoned(true);
        }
    }

    return dataSource;
}