Example usage for org.springframework.jdbc.datasource.init ResourceDatabasePopulator setIgnoreFailedDrops

List of usage examples for org.springframework.jdbc.datasource.init ResourceDatabasePopulator setIgnoreFailedDrops

Introduction

In this page you can find the example usage for org.springframework.jdbc.datasource.init ResourceDatabasePopulator setIgnoreFailedDrops.

Prototype

public void setIgnoreFailedDrops(boolean ignoreFailedDrops) 

Source Link

Document

Flag to indicate that a failed SQL DROP statement can be ignored.

Usage

From source file:com.springsource.open.db.AtomikosApplication.java

private DataSourceInitializer initialize(DataSource dataSource, String name) {
    DataSourceInitializer initializer = new DataSourceInitializer();
    initializer.setDataSource(dataSource);
    ResourceDatabasePopulator populator = new ResourceDatabasePopulator(new ClassPathResource(name + ".sql"));
    populator.setIgnoreFailedDrops(true);
    initializer.setDatabasePopulator(populator);
    return initializer;
}

From source file:com.github.ferstl.spring.jdbc.oracle.DatabaseConfiguration.java

private void prepareDatabase() {
    final ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
    populator.addScript(new ClassPathResource("prepare-database.sql"));
    populator.setIgnoreFailedDrops(true);

    TransactionTemplate trxTemplate = new TransactionTemplate(transactionManager());
    trxTemplate.execute(new TransactionCallback<Void>() {

        @Override/* ww  w . j av a2  s.  c  o m*/
        public Void doInTransaction(TransactionStatus status) {
            DatabasePopulatorUtils.execute(populator, DatabaseConfiguration.this.dataSource);
            return null;
        }
    });
}

From source file:org.springframework.cloud.stream.module.jdbc.JdbcSinkConfiguration.java

@ConditionalOnProperty("initialize")
@Bean//from w  ww  .  j  a v  a  2s  .c o m
public DataSourceInitializer nonBootDataSourceInitializer(DataSource dataSource,
        ResourceLoader resourceLoader) {
    DataSourceInitializer dataSourceInitializer = new DataSourceInitializer();
    dataSourceInitializer.setDataSource(dataSource);
    ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();
    databasePopulator.setIgnoreFailedDrops(true);
    dataSourceInitializer.setDatabasePopulator(databasePopulator);
    if ("true".equals(properties.getInitialize())) {
        databasePopulator.addScript(new DefaultInitializationScriptResource(properties));
    } else {
        databasePopulator.addScript(resourceLoader.getResource(properties.getInitialize()));
    }
    return dataSourceInitializer;
}

From source file:org.springframework.cloud.stream.app.jdbc.sink.JdbcSinkConfiguration.java

@ConditionalOnProperty("jdbc.initialize")
@Bean//from   w  w  w.  ja va2 s  .com
public DataSourceInitializer nonBootDataSourceInitializer(DataSource dataSource,
        ResourceLoader resourceLoader) {
    DataSourceInitializer dataSourceInitializer = new DataSourceInitializer();
    dataSourceInitializer.setDataSource(dataSource);
    ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();
    databasePopulator.setIgnoreFailedDrops(true);
    dataSourceInitializer.setDatabasePopulator(databasePopulator);
    if ("true".equals(properties.getInitialize())) {
        databasePopulator.addScript(new DefaultInitializationScriptResource(properties));
    } else {
        databasePopulator.addScript(resourceLoader.getResource(properties.getInitialize()));
    }
    return dataSourceInitializer;
}

From source file:org.cloudfoundry.identity.uaa.db.InitialPreDatabaseVersioningSchemaCreator.java

@Override
public void migrate(Connection connection) throws Exception {
    ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
    populator.addScript(//from   www .  j  a  va  2  s .  co m
            new ClassPathResource("org/cloudfoundry/identity/uaa/db/" + type + "/V1_5_2__initial_db.sql"));
    populator.setContinueOnError(true);
    populator.setIgnoreFailedDrops(true);
    populator.populate(connection);
}

From source file:com.vladmihalcea.util.DatabaseScriptLifecycleHandler.java

protected ResourceDatabasePopulator createResourceDatabasePopulator() {
    ResourceDatabasePopulator resourceDatabasePopulator = new ResourceDatabasePopulator();
    resourceDatabasePopulator.setCommentPrefix(getCommentPrefix());
    resourceDatabasePopulator.setContinueOnError(isContinueOnError());
    resourceDatabasePopulator.setIgnoreFailedDrops(isIgnoreFailedDrops());
    resourceDatabasePopulator.setSqlScriptEncoding(getSqlScriptEncoding());
    return resourceDatabasePopulator;
}

From source file:org.cloudfoundry.identity.uaa.db.FixFailedBackportMigrations_4_0_4.java

@Override
public void migrate(Connection connection) throws Exception {
    if ("sqlserver".equals(type) || "hsqldb".equals(type)) {
        //we don't have this problem with sqlserver or in memory DB
        logger.info("Skipping 4.0.4 migration for " + type + ", not affected by 3.9.9 back ports.");
        return;/*from  w ww. j  av  a  2  s.c om*/
    }
    ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
    SingleConnectionDataSource dataSource = new SingleConnectionDataSource(connection, true);
    JdbcTemplate template = new JdbcTemplate(dataSource);
    boolean run = false;
    for (Map.Entry<String, String> script : getScripts()) {
        int count = template.queryForObject(checkExistsSql, Integer.class, script.getKey());
        if (count == 0) {
            String path = "org/cloudfoundry/identity/uaa/db/" + type + "/" + script.getValue();
            logger.info(
                    String.format("[4.0.4] Adding script for version %s with path %s", script.getKey(), path));
            populator.addScript(new ClassPathResource(path));
            run = true;
        }
    }
    if (run) {
        logger.info("Running missing migrations.");
        populator.setContinueOnError(false);
        populator.setIgnoreFailedDrops(true);
        populator.populate(connection);
        logger.info("Completed missing migrations.");
    } else {
        logger.info("Skipping 4.0.4 migrations, no migrations missing.");
    }
}

From source file:org.springframework.test.context.jdbc.DatabaseInitializerTestExecutionListener.java

/**
 * Execute the SQL scripts configured via the supplied
 * {@link DatabaseInitializer @DatabaseInitializer} for the given
 * {@link ExecutionPhase} and {@link TestContext}.
 *
 * <p>Special care must be taken in order to properly support the
 * {@link DatabaseInitializer#requireNewTransaction requireNewTransaction}
 * flag.//from   w ww .j  ava 2 s  .c om
 *
 * @param databaseInitializer the {@code @DatabaseInitializer} to parse
 * @param executionPhase the current execution phase
 * @param testContext the current {@code TestContext}
 * @param classLevel {@code true} if {@link DatabaseInitializer @DatabaseInitializer}
 * was declared at the class level
 */
@SuppressWarnings("serial")
private void executeDatabaseInitializer(DatabaseInitializer databaseInitializer, ExecutionPhase executionPhase,
        TestContext testContext, boolean classLevel) throws Exception {
    if (logger.isDebugEnabled()) {
        logger.debug(String.format("Processing %s for execution phase [%s] and test context %s.",
                databaseInitializer, executionPhase, testContext));
    }

    if (executionPhase != databaseInitializer.executionPhase()) {
        return;
    }

    final ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
    populator.setSqlScriptEncoding(databaseInitializer.encoding());
    populator.setSeparator(databaseInitializer.separator());
    populator.setCommentPrefix(databaseInitializer.commentPrefix());
    populator.setBlockCommentStartDelimiter(databaseInitializer.blockCommentStartDelimiter());
    populator.setBlockCommentEndDelimiter(databaseInitializer.blockCommentEndDelimiter());
    populator.setContinueOnError(databaseInitializer.continueOnError());
    populator.setIgnoreFailedDrops(databaseInitializer.ignoreFailedDrops());

    String[] scripts = getScripts(databaseInitializer, testContext, classLevel);
    scripts = TestContextResourceUtils.convertToClasspathResourcePaths(testContext.getTestClass(), scripts);
    populator.setScripts(
            TestContextResourceUtils.convertToResources(testContext.getApplicationContext(), scripts));
    if (logger.isDebugEnabled()) {
        logger.debug("Executing SQL scripts: " + ObjectUtils.nullSafeToString(scripts));
    }

    final DataSource dataSource = TestContextTransactionUtils.retrieveDataSource(testContext,
            databaseInitializer.dataSource());
    final PlatformTransactionManager transactionManager = TestContextTransactionUtils
            .retrieveTransactionManager(testContext, databaseInitializer.transactionManager());

    int propagation = databaseInitializer.requireNewTransaction()
            ? TransactionDefinition.PROPAGATION_REQUIRES_NEW
            : TransactionDefinition.PROPAGATION_REQUIRED;

    TransactionAttribute transactionAttribute = TestContextTransactionUtils
            .createDelegatingTransactionAttribute(testContext, new DefaultTransactionAttribute(propagation));

    new TransactionTemplate(transactionManager, transactionAttribute)
            .execute(new TransactionCallbackWithoutResult() {

                @Override
                public void doInTransactionWithoutResult(TransactionStatus status) {
                    populator.execute(dataSource);
                };
            });
}

From source file:org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener.java

/**
 * Execute the SQL scripts configured via the supplied {@link Sql @Sql}
 * annotation for the given {@link ExecutionPhase} and {@link TestContext}.
 * <p>Special care must be taken in order to properly support the configured
 * {@link SqlConfig#transactionMode}.// w  w w.  j  a va 2 s . c o m
 * @param sql the {@code @Sql} annotation to parse
 * @param executionPhase the current execution phase
 * @param testContext the current {@code TestContext}
 * @param classLevel {@code true} if {@link Sql @Sql} was declared at the class level
 */
private void executeSqlScripts(Sql sql, ExecutionPhase executionPhase, TestContext testContext,
        boolean classLevel) throws Exception {

    if (executionPhase != sql.executionPhase()) {
        return;
    }

    MergedSqlConfig mergedSqlConfig = new MergedSqlConfig(sql.config(), testContext.getTestClass());
    if (logger.isDebugEnabled()) {
        logger.debug(String.format("Processing %s for execution phase [%s] and test context %s.",
                mergedSqlConfig, executionPhase, testContext));
    }

    final ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
    populator.setSqlScriptEncoding(mergedSqlConfig.getEncoding());
    populator.setSeparator(mergedSqlConfig.getSeparator());
    populator.setCommentPrefix(mergedSqlConfig.getCommentPrefix());
    populator.setBlockCommentStartDelimiter(mergedSqlConfig.getBlockCommentStartDelimiter());
    populator.setBlockCommentEndDelimiter(mergedSqlConfig.getBlockCommentEndDelimiter());
    populator.setContinueOnError(mergedSqlConfig.getErrorMode() == ErrorMode.CONTINUE_ON_ERROR);
    populator.setIgnoreFailedDrops(mergedSqlConfig.getErrorMode() == ErrorMode.IGNORE_FAILED_DROPS);

    String[] scripts = getScripts(sql, testContext, classLevel);
    scripts = TestContextResourceUtils.convertToClasspathResourcePaths(testContext.getTestClass(), scripts);
    List<Resource> scriptResources = TestContextResourceUtils
            .convertToResourceList(testContext.getApplicationContext(), scripts);
    for (String stmt : sql.statements()) {
        if (StringUtils.hasText(stmt)) {
            stmt = stmt.trim();
            scriptResources.add(new ByteArrayResource(stmt.getBytes(), "from inlined SQL statement: " + stmt));
        }
    }
    populator.setScripts(scriptResources.toArray(new Resource[scriptResources.size()]));
    if (logger.isDebugEnabled()) {
        logger.debug("Executing SQL scripts: " + ObjectUtils.nullSafeToString(scriptResources));
    }

    String dsName = mergedSqlConfig.getDataSource();
    String tmName = mergedSqlConfig.getTransactionManager();
    DataSource dataSource = TestContextTransactionUtils.retrieveDataSource(testContext, dsName);
    PlatformTransactionManager txMgr = TestContextTransactionUtils.retrieveTransactionManager(testContext,
            tmName);
    boolean newTxRequired = (mergedSqlConfig.getTransactionMode() == TransactionMode.ISOLATED);

    if (txMgr == null) {
        Assert.state(!newTxRequired,
                () -> String.format(
                        "Failed to execute SQL scripts for test context %s: "
                                + "cannot execute SQL scripts using Transaction Mode "
                                + "[%s] without a PlatformTransactionManager.",
                        testContext, TransactionMode.ISOLATED));
        Assert.state(dataSource != null,
                () -> String.format("Failed to execute SQL scripts for test context %s: "
                        + "supply at least a DataSource or PlatformTransactionManager.", testContext));
        // Execute scripts directly against the DataSource
        populator.execute(dataSource);
    } else {
        DataSource dataSourceFromTxMgr = getDataSourceFromTransactionManager(txMgr);
        // Ensure user configured an appropriate DataSource/TransactionManager pair.
        if (dataSource != null && dataSourceFromTxMgr != null && !dataSource.equals(dataSourceFromTxMgr)) {
            throw new IllegalStateException(String.format(
                    "Failed to execute SQL scripts for test context %s: "
                            + "the configured DataSource [%s] (named '%s') is not the one associated with "
                            + "transaction manager [%s] (named '%s').",
                    testContext, dataSource.getClass().getName(), dsName, txMgr.getClass().getName(), tmName));
        }
        if (dataSource == null) {
            dataSource = dataSourceFromTxMgr;
            Assert.state(dataSource != null, () -> String.format("Failed to execute SQL scripts for "
                    + "test context %s: could not obtain DataSource from transaction manager [%s] (named '%s').",
                    testContext, txMgr.getClass().getName(), tmName));
        }
        final DataSource finalDataSource = dataSource;
        int propagation = (newTxRequired ? TransactionDefinition.PROPAGATION_REQUIRES_NEW
                : TransactionDefinition.PROPAGATION_REQUIRED);
        TransactionAttribute txAttr = TestContextTransactionUtils.createDelegatingTransactionAttribute(
                testContext, new DefaultTransactionAttribute(propagation));
        new TransactionTemplate(txMgr, txAttr).execute(status -> {
            populator.execute(finalDataSource);
            return null;
        });
    }
}