Java DatabaseException类代码示例

import liquibase.exception.DatabaseException; //导入依赖的package包/类
@Override
    public void tag(final String tagString) throws DatabaseException {
        Database database = getDatabase();
        Executor executor = ExecutorService.getInstance().getExecutor(database);
        try {
            int totalRows = ExecutorService.getInstance().getExecutor(database).queryForInt(new SelectFromDatabaseChangeLogStatement(new ColumnConfig().setName("COUNT(*)", true)));
            if (totalRows == 0) {
                ChangeSet emptyChangeSet = new ChangeSet(String.valueOf(new Date().getTime()), "liquibase", false, false, "liquibase-internal", null, null, getDatabase().getObjectQuotingStrategy(), null);
                this.setExecType(emptyChangeSet, ChangeSet.ExecType.EXECUTED);
            }

//            Timestamp lastExecutedDate = (Timestamp) this.getExecutor().queryForObject(createChangeToTagSQL(), Timestamp.class);
            executor.execute(new TagDatabaseStatement(tagString));
            getDatabase().commit();

            if (this.ranChangeSetList != null) {
                ranChangeSetList.get(ranChangeSetList.size() - 1).setTag(tagString);
            }
        } catch (Exception e) {
            throw new DatabaseException(e);
        }
    }
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
public static void connectToDB() throws Exception {
    if (connection == null) {
        info = new Properties();
        info.load(new FileInputStream("src/test/resources/liquibase.properties"));

        url = info.getProperty("url");
        driver = (Driver) Class.forName(DatabaseFactory.getInstance().findDefaultDriver(url), true,
                Thread.currentThread().getContextClassLoader()).newInstance();

        connection = driver.connect(url, info);

        if (connection == null) {
            throw new DatabaseException("Connection could not be created to " + url + " with driver "
                    + driver.getClass().getName() + ".  Possibly the wrong driver for the given database URL");
        }

        jdbcConnection = new JdbcConnection(connection);
    }
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
@Override
public int update(SqlStatement sql) throws DatabaseException
{
	if (sql instanceof LockDatabaseChangeLogStatement)
	{
		return 1;
	}
	else if (sql instanceof UnlockDatabaseChangeLogStatement)
	{
		return 1;
	}

	suppressSqlStatement(sql);

	return 0;
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
protected Database createDatabase(Connection c, ResourceAccessor resourceAccessor) throws DatabaseException {

        DatabaseConnection liquibaseConnection = new JdbcConnection(c);
        DatabaseFactory databaseFactory = DatabaseFactory.getInstance();

        // expand factory with our extensions....
        databaseFactory.register(new DerbyDatabase());

        Database database = databaseFactory.findCorrectDatabaseImplementation(liquibaseConnection);
        // set default schema
        String defaultSchema = cli.optionString(LiquibaseModule.DEFAULT_SCHEMA_OPTION);
        if (defaultSchema != null) {
            database.setDefaultSchemaName(defaultSchema);
        }

        return database;
    }
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
@Override
public void close() throws DatabaseException {

    // copy-paste from AbstractJdbcDatabase plus reflection to deal with private fields...

    ExecutorService.getInstance().clearExecutor(this);
    DatabaseConnection connection = getConnection();
    if (connection != null) {

        Boolean previousAutoCommit = previousAutoCommit();
        if (previousAutoCommit != null) {
            try {
                connection.setAutoCommit(previousAutoCommit);
            } catch (DatabaseException e) {
                LogFactory.getInstance().getLog().warning("Failed to restore the auto commit to " + previousAutoCommit);
                throw e;
            }
        }
        connection.close();
    }
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
public static void connectToDB() throws Exception {
	if ( connection == null ) {
		info = new Properties();
		info.load( new FileInputStream( "src/test/resources/tests.properties" ) );

		url = info.getProperty( "url" );
		driver = (Driver) Class.forName( DatabaseFactory.getInstance().findDefaultDriver( url ), true, Thread.currentThread().getContextClassLoader() ).newInstance();

		connection = driver.connect( url, info );

		if ( connection == null ) {
			throw new DatabaseException( "Connection could not be created to " + url + " with driver " + driver.getClass().getName() + ".  Possibly the wrong driver for the given database URL" );
		}

		jdbcConnection = new JdbcConnection( connection );
	}
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
/**
 * Fill foreign key information from the current register of a getImportedKeys resultset
 * 
 * @param rs The resultset returned by getImportedKeys
 * @return Foreign key information
 */
protected ForeignKeyInfo fillForeignKeyInfo(ResultSet rs) throws DatabaseException, SQLException {
	ForeignKeyInfo fkInfo = new ForeignKeyInfo();
	fkInfo.setFkName(convertFromDatabaseName(rs.getString("FK_NAME")));
	fkInfo.setFkSchema(convertFromDatabaseName(rs.getString("FKTABLE_SCHEM")));
	fkInfo.setFkTableName(convertFromDatabaseName(rs.getString("FKTABLE_NAME")));
	fkInfo.setFkColumn(convertFromDatabaseName(rs.getString("FKCOLUMN_NAME")));
	fkInfo.setPkTableSchema(rs.getString("PKTABLE_SCHEM"));
	fkInfo.setPkTableName(convertFromDatabaseName(rs.getString("PKTABLE_NAME")));
	fkInfo.setPkColumn(convertFromDatabaseName(rs.getString("PKCOLUMN_NAME")));
	fkInfo.setKeySeq(rs.getInt("KEY_SEQ"));
	ForeignKeyConstraintType updateRule = convertToForeignKeyConstraintType(rs.getInt("UPDATE_RULE"));
	if (rs.wasNull()) {
		updateRule = null;
	}
	fkInfo.setUpdateRule(updateRule);
	ForeignKeyConstraintType deleteRule = convertToForeignKeyConstraintType(rs.getInt("DELETE_RULE"));
	if (rs.wasNull()) {
		deleteRule = null;
	}
	fkInfo.setDeleteRule(deleteRule);
	fkInfo.setDeferrablility(rs.getShort("DEFERRABILITY"));
	return fkInfo;
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
@Test(dataProvider = "generateSqlTestData")
public void testGenerateSql(final DropColumnStatement statement, final Database database,
      final Sql[] expected) throws DatabaseException {
   final DropGeometryColumnGeneratorGeoDB generator = new DropGeometryColumnGeneratorGeoDB();
   final SqlGeneratorChain sqlGeneratorChain = mock(SqlGeneratorChain.class);
   when(sqlGeneratorChain.generateSql(statement, database)).thenReturn(new Sql[0]);
   final Sql[] result = generator.generateSql(statement, database, sqlGeneratorChain);
   assertEquals(result.length, expected.length);
   if (result.length > 0) {
      for (int ii = 0; ii < result.length; ii++) {
         final Sql resultSql = result[ii];
         final Sql expectedSql = expected[ii];
         assertEquals(resultSql.toSql(), expectedSql.toSql());
      }
   }
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
public Sql[] generateSql(FindForeignKeyConstraintsStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
    StringBuilder sb = new StringBuilder();

    sb.append("SELECT ");
    sb.append("RC.TABLE_NAME as ").append(FindForeignKeyConstraintsStatement.RESULT_COLUMN_BASE_TABLE_NAME).append(", ");
    sb.append("KCU.COLUMN_NAME as ").append(FindForeignKeyConstraintsStatement.RESULT_COLUMN_BASE_TABLE_COLUMN_NAME).append(", ");
    sb.append("RC.REFERENCED_TABLE_NAME ").append(FindForeignKeyConstraintsStatement.RESULT_COLUMN_FOREIGN_TABLE_NAME).append(", ");
    sb.append("KCU.REFERENCED_COLUMN_NAME as ").append(FindForeignKeyConstraintsStatement.RESULT_COLUMN_FOREIGN_COLUMN_NAME).append(", ");
    sb.append("RC.CONSTRAINT_NAME as ").append(FindForeignKeyConstraintsStatement.RESULT_COLUMN_CONSTRAINT_NAME).append(" ");
    sb.append("FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS RC,");
    sb.append("     INFORMATION_SCHEMA.KEY_COLUMN_USAGE KCU ");
    sb.append("WHERE RC.TABLE_NAME = KCU.TABLE_NAME ");
    sb.append("AND RC.CONSTRAINT_SCHEMA = KCU.CONSTRAINT_SCHEMA ");
    sb.append("AND RC.CONSTRAINT_NAME = KCU.CONSTRAINT_NAME ");
    sb.append("AND RC.TABLE_NAME = '").append(statement.getBaseTableName()).append("' ");
    try {
        sb.append("AND RC.CONSTRAINT_SCHEMA = '").append(database.convertRequestedSchemaToSchema(null)).append("'");
    } catch (DatabaseException e) {
        throw new UnexpectedLiquibaseException(e);
    }
    return new Sql[]{
            new UnparsedSql(sb.toString())
    };
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
public Column getColumn(String schemaName, String tableName, String columnName, Database database)
		throws DatabaseException {
	ResultSet rs = null;
	try {
		rs = getMetaData(database).getColumns(database.convertRequestedSchemaToCatalog(schemaName),
				database.convertRequestedSchemaToSchema(schemaName),
				convertTableNameToDatabaseTableName(tableName), convertColumnNameToDatabaseTableName(columnName));

		if (!rs.next()) {
			return null;
		}

		return readColumn(rs, database);
	} catch (Exception e) {
		throw new DatabaseException(e);
	} finally {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException ignore) {
			}
		}
	}
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
public List<ForeignKey> getForeignKeys(String schemaName, String foreignKeyTableName, Database database)
		throws DatabaseException {
	List<ForeignKey> fkList = new ArrayList<ForeignKey>();
	try {
		String dbCatalog = database.convertRequestedSchemaToCatalog(schemaName);
		String dbSchema = database.convertRequestedSchemaToSchema(schemaName);
		ResultSet rs = getMetaData(database).getImportedKeys(dbCatalog, dbSchema,
				convertTableNameToDatabaseTableName(foreignKeyTableName));

		try {
			while (rs.next()) {
				ForeignKeyInfo fkInfo = fillForeignKeyInfo(rs);

				fkList.add(generateForeignKey(fkInfo, database, fkList));
			}
		} finally {
			rs.close();
		}

		return fkList;

	} catch (Exception e) {
		throw new DatabaseException(e);
	}
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
public Sql[] generateSql(SelectSequencesStatement statement, Database database, SqlGeneratorChain sqlGeneratorChain) {
    try {
        String schema = statement.getSchemaName();
        
        return new Sql[] {
                new UnparsedSql("SELECT relname AS SEQUENCE_NAME FROM pg_class, pg_namespace " +
            "WHERE relkind='S' " +
            "AND pg_class.relnamespace = pg_namespace.oid " +
            "AND nspname = '" + database.convertRequestedSchemaToSchema(schema) + "' " +
            "AND 'nextval(''" + (schema == null ? "" : schema + ".") + "'||relname||'''::regclass)' not in (select adsrc from pg_attrdef where adsrc is not null) " +
            "AND 'nextval(''" + (schema == null ? "" : schema + ".") + "\"'||relname||'\"''::regclass)' not in (select adsrc from pg_attrdef where adsrc is not null) " +
            "AND 'nextval('''||relname||'''::regclass)' not in (select adsrc from pg_attrdef where adsrc is not null)")
        };
    } catch (DatabaseException e) {
        throw new UnexpectedLiquibaseException(e);
    }
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
public Map call(CallableSqlStatement csc, final List declaredParameters, List<SqlVisitor> sqlVisitors) throws DatabaseException {
        return (Map) execute(csc, new CallableStatementCallback() {
            public Object doInCallableStatement(CallableStatement cs) throws SQLException {
                //not currently doing anything with returned results
//                boolean retVal = cs.execute();
//                int updateCount = cs.getUpdateCount();
//                Map returnedResults = new HashMap();
//                if (retVal || updateCount != -1) {
//                    returnedResults.putAll(extractReturnedResultSets(cs, declaredParameters, updateCount));
//                }
//                returnedResults.putAll(extractOutputParameters(cs, declaredParameters));
                cs.execute();
                return new HashMap();
            }
        }, sqlVisitors);
    }
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
public Object execute(StatementCallback action, List<SqlVisitor> sqlVisitors) throws DatabaseException {
    DatabaseConnection con = database.getConnection();
    Statement stmt = null;
    try {
        stmt = ((JdbcConnection) con).getUnderlyingConnection().createStatement();
        Statement stmtToUse = stmt;

        return action.doInStatement(stmtToUse);
    }
    catch (SQLException ex) {
        // Release Connection early, to avoid potential connection pool deadlock
        // in the case when the exception translator hasn't been initialized yet.
        JdbcUtils.closeStatement(stmt);
        stmt = null;
        throw new DatabaseException("Error executing SQL " + StringUtils.join(applyVisitors(action.getStatement(), sqlVisitors), "; on "+ con.getURL())+": "+ex.getMessage(), ex);
    }
    finally {
        JdbcUtils.closeStatement(stmt);
    }
}
 

import liquibase.exception.DatabaseException; //导入依赖的package包/类
/**
 * Oracle specific implementation
 */
@Override
protected void getColumnTypeAndDefValue(Column columnInfo, ResultSet rs, Database database) throws SQLException, DatabaseException {
    super.getColumnTypeAndDefValue(columnInfo, rs, database);

    // Exclusive setting for oracle INTEGER type
    // Details:
    // INTEGER means NUMBER type with 'data_precision IS NULL and scale = 0'
    if (columnInfo.getDataType() == Types.INTEGER) {
        columnInfo.setTypeName("INTEGER");
    }

    String columnTypeName = rs.getString("TYPE_NAME");
    if ("VARCHAR2".equals(columnTypeName)) {
        int charOctetLength = rs.getInt("CHAR_OCTET_LENGTH");
        int columnSize = rs.getInt("COLUMN_SIZE");
        if (columnSize == charOctetLength) {
            columnInfo.setLengthSemantics(Column.LengthSemantics.BYTE);
        } else {
            columnInfo.setLengthSemantics(Column.LengthSemantics.CHAR);
        }
    }
}