Examples with DatabaseException liquibase.exception.DatabaseException used on opensource projects

Example 16 with DatabaseException

use of liquibase.exception.DatabaseException in project liquibase by liquibase.

the class ColumnSnapshotGenerator method setAutoIncrementDetails.

protected void setAutoIncrementDetails(Column column, Database database, DatabaseSnapshot snapshot) {
    if (column.getAutoIncrementInformation() != null && database instanceof MSSQLDatabase && database.getConnection() != null && !(database.getConnection() instanceof OfflineConnection)) {
        Map<String, Column.AutoIncrementInformation> autoIncrementColumns = (Map) snapshot.getScratchData("autoIncrementColumns");
        if (autoIncrementColumns == null) {
            autoIncrementColumns = new HashMap<String, Column.AutoIncrementInformation>();
            Executor executor = ExecutorService.getInstance().getExecutor(database);
            try {
                List<Map<String, ?>> rows = executor.queryForList(new RawSqlStatement("select object_schema_name(object_id) as schema_name, object_name(object_id) as table_name, name as column_name, cast(seed_value as bigint) as start_value, cast(increment_value as bigint) as increment_by from sys.identity_columns"));
                for (Map row : rows) {
                    String schemaName = (String) row.get("SCHEMA_NAME");
                    String tableName = (String) row.get("TABLE_NAME");
                    String columnName = (String) row.get("COLUMN_NAME");
                    Long startValue = (Long) row.get("START_VALUE");
                    Long incrementBy = (Long) row.get("INCREMENT_BY");
                    Column.AutoIncrementInformation info = new Column.AutoIncrementInformation(startValue, incrementBy);
                    autoIncrementColumns.put(schemaName + "." + tableName + "." + columnName, info);
                }
                snapshot.setScratchData("autoIncrementColumns", autoIncrementColumns);
            } catch (DatabaseException e) {
                LogFactory.getInstance().getLog().info("Could not read identity information", e);
            }
        }
        if (column.getRelation() != null && column.getSchema() != null) {
            Column.AutoIncrementInformation autoIncrementInformation = autoIncrementColumns.get(column.getSchema().getName() + "." + column.getRelation().getName() + "." + column.getName());
            if (autoIncrementInformation != null) {
                column.setAutoIncrementInformation(autoIncrementInformation);
            }
        }
    }
}

Example 17 with DatabaseException

use of liquibase.exception.DatabaseException in project liquibase by liquibase.

the class DataSnapshotGenerator method addTo.

@Override
protected void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
    if (!snapshot.getSnapshotControl().shouldInclude(Data.class)) {
        return;
    }
    if (foundObject instanceof Table) {
        Table table = (Table) foundObject;
        try {
            Data exampleData = new Data().setTable(table);
            table.setAttribute("data", exampleData);
        } catch (Exception e) {
            throw new DatabaseException(e);
        }
    }
}

Example 18 with DatabaseException

use of liquibase.exception.DatabaseException in project liquibase by liquibase.

the class IndexSnapshotGenerator method addTo.

//    public Boolean has(DatabaseObject example, DatabaseSnapshot snapshot, SnapshotGeneratorChain chain) throws DatabaseException {
//        Database database = snapshot.getDatabase();
//        if (!(example instanceof Index)) {
//            return chain.has(example, snapshot);
//        }
//        String tableName = ((Index) example).getTable().getName();
//        Schema schema = example.getSchema();
//
//        String indexName = example.getName();
//        String columnNames = ((Index) example).getColumnNames();
//
//        try {
//            if (tableName == null) {
//                Index newExample = new Index();
//                newExample.setName(indexName);
//                if (columnNames != null) {
//                    for (String column : columnNames.split("\\s*,\\s*")) {
//                        newExample.getColumns().add(column);
//                    }
//                }
//
//                ResultSet rs = getMetaData(database).getTables(database.getJdbcCatalogName(schema), database.getJdbcSchemaName(schema), null, new String[]{"TABLE"});
//                try {
//                    while (rs.next()) {
//                        String foundTable = rs.getString("TABLE_NAME");
//                        newExample.setTable((Table) new Table().setName(foundTable).setSchema(schema));
//                        if (has(newExample, snapshot, chain)) {
//                            return true;
//                        }
//                    }
//                    return false;
//                } finally {
//                    rs.close();
//                }
//            }
//
//            Index index = new Index();
//            index.setTable((Table) new Table().setName(tableName).setSchema(schema));
//            index.setName(indexName);
//            if (columnNames != null) {
//                for (String column : columnNames.split("\\s*,\\s*")) {
//                    index.getColumns().add(column);
//                }
//            }
//
//            if (columnNames != null) {
//                Map<String, TreeMap<Short, String>> columnsByIndexName = new HashMap<String, TreeMap<Short, String>>();
//                ResultSet rs = getMetaData(database).getIndexInfo(database.getJdbcCatalogName(schema), database.getJdbcSchemaName(schema), database.correctObjectName(tableName, Table.class), false, true);
//                try {
//                    while (rs.next()) {
//                        String foundIndexName = rs.getString("INDEX_NAME");
//                        if (indexName != null && indexName.equalsIgnoreCase(foundIndexName)) { //ok to use equalsIgnoreCase because we will check case later
//                            continue;
//                        }
//                        short ordinalPosition = rs.getShort("ORDINAL_POSITION");
//
//                        if (!columnsByIndexName.containsKey(foundIndexName)) {
//                            columnsByIndexName.put(foundIndexName, new TreeMap<Short, String>());
//                        }
//                        String columnName = rs.getString("COLUMN_NAME");
//                        Map<Short, String> columns = columnsByIndexName.get(foundIndexName);
//                        columns.put(ordinalPosition, columnName);
//                    }
//
//                    for (Map.Entry<String, TreeMap<Short, String>> foundIndexData : columnsByIndexName.entrySet()) {
//                        Index foundIndex = new Index()
//                                .setName(foundIndexData.getKey())
//                                .setTable(((Table) new Table().setName(tableName).setSchema(schema)));
//                        foundIndex.getColumns().addAll(foundIndexData.getValue().values());
//
//                        if (foundIndex.equals(index, database)) {
//                            return true;
//                        }
//                        return false;
//                    }
//                    return false;
//                } finally {
//                    rs.close();
//                }
//            } else if (indexName != null) {
//                ResultSet rs = getMetaData(database).getIndexInfo(database.getJdbcCatalogName(schema), database.getJdbcSchemaName(schema), database.correctObjectName(tableName, Table.class), false, true);
//                try {
//                    while (rs.next()) {
//                        Index foundIndex = new Index()
//                                .setName(rs.getString("INDEX_NAME"))
//                                .setTable(((Table) new Table().setName(tableName).setSchema(schema)));
//                        if (foundIndex.getName() == null) {
//                            continue;
//                        }
//                        if (foundIndex.equals(index, database)) {
//                            return true;
//                        }
//                    }
//                    return false;
//                } finally {
//                    try {
//                        rs.close();
//                    } catch (SQLException ignore) {
//                    }
//                }
//            } else {
//                throw new UnexpectedLiquibaseException("Either indexName or columnNames must be set");
//            }
//        } catch (SQLException e) {
//            throw new DatabaseException(e);
//        }
//
//    }
@Override
protected void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
    if (!snapshot.getSnapshotControl().shouldInclude(Index.class)) {
        return;
    }
    if (foundObject instanceof Table) {
        Table table = (Table) foundObject;
        Database database = snapshot.getDatabase();
        Schema schema;
        schema = table.getSchema();
        List<CachedRow> rs = null;
        JdbcDatabaseSnapshot.CachingDatabaseMetaData databaseMetaData = null;
        try {
            databaseMetaData = ((JdbcDatabaseSnapshot) snapshot).getMetaData();
            rs = databaseMetaData.getIndexInfo(((AbstractJdbcDatabase) database).getJdbcCatalogName(schema), ((AbstractJdbcDatabase) database).getJdbcSchemaName(schema), table.getName(), null);
            Map<String, Index> foundIndexes = new HashMap<String, Index>();
            for (CachedRow row : rs) {
                String indexName = row.getString("INDEX_NAME");
                if (indexName == null) {
                    continue;
                }
                if (database instanceof DB2Database && "SYSIBM".equals(row.getString("INDEX_QUALIFIER"))) {
                    continue;
                }
                Index index = foundIndexes.get(indexName);
                if (index == null) {
                    index = new Index();
                    index.setName(indexName);
                    index.setTable(table);
                    short type = row.getShort("TYPE");
                    if (type == DatabaseMetaData.tableIndexClustered) {
                        index.setClustered(true);
                    } else if (database instanceof MSSQLDatabase) {
                        index.setClustered(false);
                    }
                    foundIndexes.put(indexName, index);
                }
                String ascOrDesc = row.getString("ASC_OR_DESC");
                Boolean descending = "D".equals(ascOrDesc) ? Boolean.TRUE : "A".equals(ascOrDesc) ? Boolean.FALSE : null;
                index.addColumn(new Column(row.getString("COLUMN_NAME")).setComputed(false).setDescending(descending).setRelation(index.getTable()));
            }
            //add clustered indexes first, than all others in case there is a clustered and non-clustered version of the same index. Prefer the clustered version
            List<Index> stillToAdd = new ArrayList<Index>();
            for (Index exampleIndex : foundIndexes.values()) {
                if (exampleIndex.getClustered() != null && exampleIndex.getClustered()) {
                    table.getIndexes().add(exampleIndex);
                } else {
                    stillToAdd.add(exampleIndex);
                }
            }
            for (Index exampleIndex : stillToAdd) {
                boolean alreadyAddedSimilar = false;
                for (Index index : table.getIndexes()) {
                    if (DatabaseObjectComparatorFactory.getInstance().isSameObject(index, exampleIndex, null, database)) {
                        alreadyAddedSimilar = true;
                    }
                }
                if (!alreadyAddedSimilar) {
                    table.getIndexes().add(exampleIndex);
                }
            }
        } catch (Exception e) {
            throw new DatabaseException(e);
        }
    }
    //        }
    if (foundObject instanceof UniqueConstraint && ((UniqueConstraint) foundObject).getBackingIndex() == null && !(snapshot.getDatabase() instanceof DB2Database) && !(snapshot.getDatabase() instanceof DerbyDatabase)) {
        Index exampleIndex = new Index().setTable(((UniqueConstraint) foundObject).getTable());
        exampleIndex.getColumns().addAll(((UniqueConstraint) foundObject).getColumns());
        ((UniqueConstraint) foundObject).setBackingIndex(exampleIndex);
    }
}

Example 19 with DatabaseException

use of liquibase.exception.DatabaseException in project liquibase by liquibase.

the class PrimaryKeySnapshotGenerator method snapshotObject.

@Override
protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
    Database database = snapshot.getDatabase();
    Schema schema = example.getSchema();
    String searchTableName = null;
    if (((PrimaryKey) example).getTable() != null) {
        searchTableName = ((PrimaryKey) example).getTable().getName();
        searchTableName = database.correctObjectName(searchTableName, Table.class);
    }
    List<CachedRow> rs = null;
    try {
        JdbcDatabaseSnapshot.CachingDatabaseMetaData metaData = ((JdbcDatabaseSnapshot) snapshot).getMetaData();
        rs = metaData.getPrimaryKeys(((AbstractJdbcDatabase) database).getJdbcCatalogName(schema), ((AbstractJdbcDatabase) database).getJdbcSchemaName(schema), searchTableName);
        PrimaryKey returnKey = null;
        for (CachedRow row : rs) {
            if (example.getName() != null && !example.getName().equalsIgnoreCase(row.getString("PK_NAME"))) {
                continue;
            }
            String columnName = cleanNameFromDatabase(row.getString("COLUMN_NAME"), database);
            short position = row.getShort("KEY_SEQ");
            if (returnKey == null) {
                returnKey = new PrimaryKey();
                CatalogAndSchema tableSchema = ((AbstractJdbcDatabase) database).getSchemaFromJdbcInfo(row.getString("TABLE_CAT"), row.getString("TABLE_SCHEM"));
                returnKey.setTable((Table) new Table().setName(row.getString("TABLE_NAME")).setSchema(new Schema(tableSchema.getCatalogName(), tableSchema.getSchemaName())));
                returnKey.setName(row.getString("PK_NAME"));
            }
            if (database instanceof SQLiteDatabase) {
                //SQLite is zero based position?
                position = (short) (position + 1);
            }
            String ascOrDesc = row.getString("ASC_OR_DESC");
            Boolean descending = "D".equals(ascOrDesc) ? Boolean.TRUE : "A".equals(ascOrDesc) ? Boolean.FALSE : null;
            returnKey.addColumn(position - 1, new Column(columnName).setDescending(descending).setRelation(((PrimaryKey) example).getTable()));
        }
        if (returnKey != null) {
            Index exampleIndex = new Index().setTable(returnKey.getTable());
            exampleIndex.setColumns(returnKey.getColumns());
            returnKey.setBackingIndex(exampleIndex);
        }
        return returnKey;
    } catch (SQLException e) {
        throw new DatabaseException(e);
    }
}

Example 20 with DatabaseException

use of liquibase.exception.DatabaseException in project liquibase by liquibase.

the class PrimaryKeySnapshotGenerator method addTo.

@Override
protected void addTo(DatabaseObject foundObject, DatabaseSnapshot snapshot) throws DatabaseException, InvalidExampleException {
    if (!snapshot.getSnapshotControl().shouldInclude(PrimaryKey.class)) {
        return;
    }
    if (foundObject instanceof Table) {
        Table table = (Table) foundObject;
        Database database = snapshot.getDatabase();
        Schema schema = table.getSchema();
        List<CachedRow> rs = null;
        try {
            JdbcDatabaseSnapshot.CachingDatabaseMetaData metaData = ((JdbcDatabaseSnapshot) snapshot).getMetaData();
            rs = metaData.getPrimaryKeys(((AbstractJdbcDatabase) database).getJdbcCatalogName(schema), ((AbstractJdbcDatabase) database).getJdbcSchemaName(schema), table.getName());
            if (rs.size() > 0) {
                PrimaryKey primaryKey = new PrimaryKey().setName(rs.get(0).getString("PK_NAME"));
                primaryKey.setTable((Table) foundObject);
                if (!database.isSystemObject(primaryKey)) {
                    table.setPrimaryKey(primaryKey.setTable(table));
                }
            }
        } catch (SQLException e) {
            throw new DatabaseException(e);
        }
    }
}