private SequenceDefinition createDefinition(DataStore ds, int row) {
   if (ds == null || row >= ds.getRowCount()) return null;
   String name = ds.getValueAsString(row, "SEQUENCE_NAME");
   String schema = ds.getValueAsString(row, "SEQUENCE_SCHEMA");
   String db = ds.getValueAsString(row, "SEQUENCE_CATALOG");
   SequenceDefinition result = new SequenceDefinition(schema, name);
   result.setCatalog(db);
   result.setSequenceProperty(PROP_MIN_VALUE, ds.getValue(row, "minimum_value"));
   result.setSequenceProperty(PROP_MAX_VALUE, ds.getValue(row, "maximum_value"));
   result.setSequenceProperty(PROP_START_VALUE, ds.getValue(row, "start_value"));
   result.setSequenceProperty(PROP_INCREMENT, ds.getValue(row, "increment"));
   result.setSequenceProperty(
       PROP_CYCLE, Boolean.valueOf("CYCLE".equals(ds.getValueAsString(row, "cycle_flag"))));
   result.setSequenceProperty(
       PROP_IS_CACHED,
       Boolean.valueOf(StringUtil.stringToBool(ds.getValueAsString(row, "is_cached"))));
   result.setSequenceProperty(PROP_CACHE_SIZE, ds.getValue(row, "cache_size"));
   result.setSequenceProperty(PROP_CURRENT_VALUE, ds.getValue(row, "current_value"));
   result.setSequenceProperty(PROP_DATA_TYPE, ds.getValue(row, "data_type"));
   result.setSequenceProperty(PROP_USER_DATA_TYPE, ds.getValue(row, "user_type"));
   result.setSequenceProperty(PROP_PRECISION, ds.getValue(row, "precision"));
   return result;
 }
  protected DataStore getKeyList(
      TableIdentifier tbl, boolean getOwnFk, boolean includeNumericRuleValue) {
    if (cancel) return null;

    String cols[] = null;
    String refColName = null;
    DbSettings dbSettings = dbConnection.getDbSettings();

    if (getOwnFk) {
      refColName = "REFERENCES";
    } else {
      refColName = "REFERENCED BY";
    }
    int types[];
    int sizes[];

    if (includeNumericRuleValue) {
      cols =
          new String[] {
            "FK_NAME",
            "COLUMN",
            refColName,
            "UPDATE_RULE",
            "DELETE_RULE",
            "DEFERRABLE",
            "ENABLED",
            "VALIDATED",
            "UPDATE_RULE_VALUE",
            "DELETE_RULE_VALUE",
            "DEFER_RULE_VALUE"
          };
      types =
          new int[] {
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.INTEGER,
            Types.INTEGER,
            Types.INTEGER
          };
      sizes = new int[] {25, 10, 30, 12, 12, 15, 5, 5, 1, 1, 1};
    } else {
      cols =
          new String[] {
            "FK_NAME",
            "COLUMN",
            refColName,
            "UPDATE_RULE",
            "DELETE_RULE",
            "DEFERRABLE",
            "ENABLED",
            "VALIDATED"
          };
      types =
          new int[] {
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR,
            Types.VARCHAR
          };
      sizes = new int[] {25, 10, 30, 12, 12, 15, 5, 5};
    }
    DataStore ds = new DataStore(cols, types, sizes);
    if (tbl == null) return ds;

    DataStore rawList = null;

    try {
      int tableCol;
      int fkNameCol;
      int colCol;
      int fkColCol;
      int deleteActionCol = 10;
      int updateActionCol = 9;
      int schemaCol;
      int catalogCol;

      if (getOwnFk) {
        rawList = getRawKeyList(tbl, false);
        tableCol = 2;
        schemaCol = 1;
        catalogCol = 0;
        fkNameCol = 11;
        colCol = 7;
        fkColCol = 3;
      } else {
        rawList = getRawKeyList(tbl, true);
        tableCol = 6;
        schemaCol = 5;
        catalogCol = 4;
        fkNameCol = 11;
        colCol = 3;
        fkColCol = 7;
      }

      if (rawList == null) {
        // this means retrieval was cancelled
        this.cancel = true;
        return null;
      }

      for (int rawRow = 0; rawRow < rawList.getRowCount(); rawRow++) {
        String tname = rawList.getValueAsString(rawRow, tableCol);
        String schema = rawList.getValueAsString(rawRow, schemaCol);
        String catalog = rawList.getValueAsString(rawRow, catalogCol);
        TableIdentifier tid = new TableIdentifier(catalog, schema, tname, false);
        tid.setNeverAdjustCase(true);
        String tableName = tid.getTableExpression(dbConnection);

        String fk_col = rawList.getValueAsString(rawRow, fkColCol);
        String col = rawList.getValueAsString(rawRow, colCol);
        String fk_name = rawList.getValueAsString(rawRow, fkNameCol);

        int updateAction =
            rawList.getValueAsInt(rawRow, updateActionCol, DatabaseMetaData.importedKeyNoAction);
        String updActionDesc = dbSettings.getRuleDisplay(updateAction);
        int deleteAction =
            rawList.getValueAsInt(rawRow, deleteActionCol, DatabaseMetaData.importedKeyNoAction);
        String delActionDesc = dbSettings.getRuleDisplay(deleteAction);

        int deferrableCode =
            rawList.getValueAsInt(rawRow, 13, DatabaseMetaData.importedKeyNoAction);
        String deferrable = dbSettings.getRuleDisplay(deferrableCode);

        int row = ds.addRow();
        ds.setValue(row, COLUMN_IDX_FK_DEF_FK_NAME, fk_name.trim());
        ds.setValue(row, COLUMN_IDX_FK_DEF_COLUMN_NAME, col.trim());
        ds.setValue(row, COLUMN_IDX_FK_DEF_REFERENCE_COLUMN_NAME, tableName + "." + fk_col);
        ds.setValue(row, COLUMN_IDX_FK_DEF_UPDATE_RULE, updActionDesc);
        ds.setValue(row, COLUMN_IDX_FK_DEF_DELETE_RULE, delActionDesc);
        ds.setValue(row, COLUMN_IDX_FK_DEF_DEFERRABLE, deferrable);
        if (includeNumericRuleValue) {
          ds.setValue(row, COLUMN_IDX_FK_DEF_DELETE_RULE_VALUE, Integer.valueOf(deleteAction));
          ds.setValue(row, COLUMN_IDX_FK_DEF_UPDATE_RULE_VALUE, Integer.valueOf(updateAction));
          ds.setValue(
              row, COLUMN_IDX_FK_DEF_DEFERRABLE_RULE_VALUE, Integer.valueOf(deferrableCode));
        }

        if (containsStatusCol) {
          ds.setValue(row, COLUMN_IDX_FK_DEF_ENABLED, rawList.getValue(rawRow, "ENABLED"));
          ds.setValue(row, COLUMN_IDX_FK_DEF_VALIDATED, rawList.getValue(rawRow, "VALIDATED"));
        }

        if (cancel) {
          LogMgr.logWarning(
              "DefaultFKHandler.getKeyList()", "Processing of rows has been cancelled");
          break;
        }
      }
      ds.resetStatus();
    } catch (Exception e) {
      LogMgr.logError("FKHandler.getKeyList()", "Error when retrieving foreign keys", e);
      ds.reset();
    }
    return ds;
  }