Example usage for java.sql DatabaseMetaData importedKeyInitiallyDeferred

List of usage examples for java.sql DatabaseMetaData importedKeyInitiallyDeferred

Introduction

In this page you can find the example usage for java.sql DatabaseMetaData importedKeyInitiallyDeferred.

Prototype

int importedKeyInitiallyDeferred

To view the source code for java.sql DatabaseMetaData importedKeyInitiallyDeferred.

Click Source Link

Document

Indicates deferrability.

Usage

From source file:org.apache.ddlutils.task.DumpMetadataTask.java

/**
 * Dumps the foreign key columns of the indicated table to other tables.
 * /*from w  ww .  j a v a2s  .  com*/
 * @param xmlWriter   The xml writer to write to
 * @param metaData    The database metadata
 * @param catalogName The catalog name
 * @param schemaName  The schema name
 * @param tableName   The table name
 */
private void dumpFKs(PrettyPrintingXmlWriter xmlWriter, final DatabaseMetaData metaData,
        final String catalogName, final String schemaName, final String tableName) throws SQLException {
    performResultSetXmlOperation(xmlWriter, null, new ResultSetXmlOperation() {
        public ResultSet getResultSet() throws SQLException {
            return metaData.getImportedKeys(catalogName, schemaName, tableName);
        }

        public void handleRow(PrettyPrintingXmlWriter xmlWriter, ResultSet result) throws SQLException {
            Set columns = getColumnsInResultSet(result);

            xmlWriter.writeElementStart(null, "foreignKey");

            addStringAttribute(xmlWriter, "name", result, columns, "FK_NAME");
            addStringAttribute(xmlWriter, "primaryKeyName", result, columns, "PK_NAME");
            addStringAttribute(xmlWriter, "column", result, columns, "PKCOLUMN_NAME");
            addStringAttribute(xmlWriter, "foreignCatalog", result, columns, "FKTABLE_CAT");
            addStringAttribute(xmlWriter, "foreignSchema", result, columns, "FKTABLE_SCHEM");
            addStringAttribute(xmlWriter, "foreignTable", result, columns, "FKTABLE_NAME");
            addStringAttribute(xmlWriter, "foreignColumn", result, columns, "FKCOLUMN_NAME");
            addShortAttribute(xmlWriter, "sequenceNumberInFK", result, columns, "KEY_SEQ");
            if (columns.contains("UPDATE_RULE")) {
                try {
                    switch (result.getShort("UPDATE_RULE")) {
                    case DatabaseMetaData.importedKeyNoAction:
                        xmlWriter.writeAttribute(null, "updateRule", "no action");
                        break;
                    case DatabaseMetaData.importedKeyCascade:
                        xmlWriter.writeAttribute(null, "updateRule", "cascade PK change");
                        break;
                    case DatabaseMetaData.importedKeySetNull:
                        xmlWriter.writeAttribute(null, "updateRule", "set FK to NULL");
                        break;
                    case DatabaseMetaData.importedKeySetDefault:
                        xmlWriter.writeAttribute(null, "updateRule", "set FK to default");
                        break;
                    default:
                        xmlWriter.writeAttribute(null, "updateRule", "unknown");
                        break;
                    }
                } catch (SQLException ex) {
                    log("Could not read the UPDATE_RULE value for a foreign key of table '" + tableName
                            + "' from the result set: " + ex.getStackTrace(), Project.MSG_ERR);
                }
            }
            if (columns.contains("DELETE_RULE")) {
                try {
                    switch (result.getShort("DELETE_RULE")) {
                    case DatabaseMetaData.importedKeyNoAction:
                    case DatabaseMetaData.importedKeyRestrict:
                        xmlWriter.writeAttribute(null, "deleteRule", "no action");
                        break;
                    case DatabaseMetaData.importedKeyCascade:
                        xmlWriter.writeAttribute(null, "deleteRule", "cascade PK change");
                        break;
                    case DatabaseMetaData.importedKeySetNull:
                        xmlWriter.writeAttribute(null, "deleteRule", "set FK to NULL");
                        break;
                    case DatabaseMetaData.importedKeySetDefault:
                        xmlWriter.writeAttribute(null, "deleteRule", "set FK to default");
                        break;
                    default:
                        xmlWriter.writeAttribute(null, "deleteRule", "unknown");
                        break;
                    }
                } catch (SQLException ex) {
                    log("Could not read the DELETE_RULE value for a foreign key of table '" + tableName
                            + "' from the result set: " + ex.getStackTrace(), Project.MSG_ERR);
                }
            }
            if (columns.contains("DEFERRABILITY")) {
                try {
                    switch (result.getShort("DEFERRABILITY")) {
                    case DatabaseMetaData.importedKeyInitiallyDeferred:
                        xmlWriter.writeAttribute(null, "deferrability", "initially deferred");
                        break;
                    case DatabaseMetaData.importedKeyInitiallyImmediate:
                        xmlWriter.writeAttribute(null, "deferrability", "immediately deferred");
                        break;
                    case DatabaseMetaData.importedKeyNotDeferrable:
                        xmlWriter.writeAttribute(null, "deferrability", "not deferred");
                        break;
                    default:
                        xmlWriter.writeAttribute(null, "deferrability", "unknown");
                        break;
                    }
                } catch (SQLException ex) {
                    log("Could not read the DEFERRABILITY value for a foreign key of table '" + tableName
                            + "' from the result set: " + ex.getStackTrace(), Project.MSG_ERR);
                }
            }
            xmlWriter.writeElementEnd();
        }

        public void handleError(SQLException ex) {
            log("Could not determine the foreign keys for table '" + tableName + "': " + ex.getStackTrace(),
                    Project.MSG_ERR);
        }
    });
}

From source file:org.apache.openjpa.jdbc.sql.DBDictionary.java

/**
 * Create a new foreign key from the information in the schema metadata.
 *//*from   ww w . ja  va 2s  . c  om*/
protected ForeignKey newForeignKey(ResultSet fkMeta) throws SQLException {
    ForeignKey fk = new ForeignKey();
    fk.setSchemaIdentifier(fromDBName(fkMeta.getString("FKTABLE_SCHEM"), DBIdentifierType.SCHEMA));
    fk.setTableIdentifier(fromDBName(fkMeta.getString("FKTABLE_NAME"), DBIdentifierType.TABLE));
    fk.setColumnIdentifier(fromDBName(fkMeta.getString("FKCOLUMN_NAME"), DBIdentifierType.COLUMN));
    fk.setIdentifier(fromDBName(fkMeta.getString("FK_NAME"), DBIdentifierType.FOREIGN_KEY));
    fk.setPrimaryKeySchemaIdentifier(fromDBName(fkMeta.getString("PKTABLE_SCHEM"), DBIdentifierType.SCHEMA));
    fk.setPrimaryKeyTableIdentifier(fromDBName(fkMeta.getString("PKTABLE_NAME"), DBIdentifierType.TABLE));
    fk.setPrimaryKeyColumnIdentifier(fromDBName(fkMeta.getString("PKCOLUMN_NAME"), DBIdentifierType.COLUMN));
    fk.setKeySequence(fkMeta.getShort("KEY_SEQ"));
    fk.setDeferred(fkMeta.getShort("DEFERRABILITY") == DatabaseMetaData.importedKeyInitiallyDeferred);

    int del = fkMeta.getShort("DELETE_RULE");
    switch (del) {
    case DatabaseMetaData.importedKeySetNull:
        fk.setDeleteAction(ForeignKey.ACTION_NULL);
        break;
    case DatabaseMetaData.importedKeySetDefault:
        fk.setDeleteAction(ForeignKey.ACTION_DEFAULT);
        break;
    case DatabaseMetaData.importedKeyCascade:
        fk.setDeleteAction(ForeignKey.ACTION_CASCADE);
        break;
    default:
        fk.setDeleteAction(ForeignKey.ACTION_RESTRICT);
        break;
    }
    return fk;
}

From source file:org.executequery.databaseobjects.impl.TableColumnConstraint.java

private String translateDeferrabilityRule(Short value) {

    String translated = String.valueOf(value);
    if (isForeignKey()) {

        switch (value) {
        case DatabaseMetaData.importedKeyInitiallyDeferred:
            return translated + " - importedKeyInitiallyDeferred";

        case DatabaseMetaData.importedKeyInitiallyImmediate:
            return translated + " - importedKeyInitiallyImmediate";

        case DatabaseMetaData.importedKeyNotDeferrable:
            return translated + " - importedKeyNotDeferrable";
        }//from   ww w  . j a v  a  2 s . c  o m

    }
    return translated;
}

From source file:org.executequery.sql.spi.LiquibaseStatementGenerator.java

public String createTableWithConstraints(String databaseName, DatabaseTable table) {

    Database database = databaseFromName(connectionFromObject(table), databaseName);
    CreateTableChange tableChange = createTableChange(table, database);

    List<DatabaseColumn> columns = table.getColumns();
    for (DatabaseColumn column : columns) {

        if (column.hasConstraints()) {

            ColumnConfig columnConfig = columnConfigForColumn(tableChange, column);
            ConstraintsConfig constraintConfig = new ConstraintsConfig();
            for (ColumnConstraint constraint : column.getConstraints()) {

                if (constraint.isPrimaryKey()) {

                    constraintConfig.setPrimaryKey(Boolean.TRUE);
                }/*from   www. j  a  v a 2  s.c  o m*/

                if (constraint.isForeignKey()) {

                    constraintConfig.setForeignKeyName(constraint.getName());

                    constraintConfig.setReferences(
                            constraint.getReferencedTable() + "(" + constraint.getReferencedColumn() + ")");

                    constraintConfig.setDeleteCascade(
                            constraint.getDeleteRule() == DatabaseMetaData.importedKeyCascade);
                    constraintConfig.setInitiallyDeferred(
                            constraint.getDeferrability() == DatabaseMetaData.importedKeyInitiallyDeferred);
                }

                if (constraint.isUniqueKey()) {

                    constraintConfig.setUnique(Boolean.TRUE);
                    constraintConfig.setUniqueConstraintName(constraint.getName());
                }

            }

            columnConfig.setConstraints(constraintConfig);
        }

    }

    return generateStatements(tableChange, database);
}