@Override
  public boolean extendObjectList(
      WbConnection con,
      DataStore result,
      String catalog,
      String schemaPattern,
      String objectPattern,
      String[] requestedTypes) {
    if (!DbMetadata.typeIncluded("TYPE", requestedTypes)) return false;

    String select = getSelect(schemaPattern, objectPattern);
    select += " ORDER BY a.alias, s.schemaname ";

    Statement stmt = null;
    ResultSet rs = null;

    if (Settings.getInstance().getDebugMetadataSql()) {
      LogMgr.logDebug("DerbyTypeReader.extendObjectList()", "Using sql=\n" + select);
    }

    try {
      stmt = con.createStatementForQuery();
      rs = stmt.executeQuery(select);
      while (rs.next()) {
        String schema = rs.getString("schemaname");
        String name = rs.getString("type_name");
        String classname = rs.getString("javaclassname");
        String info = rs.getString("aliasinfo");
        int row = result.addRow();
        result.setValue(row, DbMetadata.COLUMN_IDX_TABLE_LIST_CATALOG, null);
        result.setValue(row, DbMetadata.COLUMN_IDX_TABLE_LIST_SCHEMA, schema);
        result.setValue(row, DbMetadata.COLUMN_IDX_TABLE_LIST_NAME, name);
        result.setValue(row, DbMetadata.COLUMN_IDX_TABLE_LIST_TYPE, "TYPE");
        result.setValue(row, DbMetadata.COLUMN_IDX_TABLE_LIST_REMARKS, null);
        DerbyTypeDefinition def = new DerbyTypeDefinition(schema, name, classname, info);
        result.getRow(row).setUserObject(def);
      }
    } catch (Exception e) {
      LogMgr.logError("DerbyTypeReader.extendObjectList()", "Error retrieving object types", e);
    } finally {
      SqlUtil.closeAll(rs, stmt);
    }
    return true;
  }
  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;
  }
  protected DataStore processResult(ResultSet rs) throws SQLException {
    if (rs == null) return null;
    DataStore ds = new DataStore(rs, false);
    boolean useColumnNames = dbConnection.getDbSettings().useColumnNameForMetadata();

    int enabledCol = -1;
    int validCol = -1;

    if (containsStatusCol) {
      enabledCol = JdbcUtils.getColumnIndex(rs, "ENABLED");
      validCol = JdbcUtils.getColumnIndex(rs, "VALIDATED");
    }

    try {
      while (rs.next()) {
        if (cancel) {
          LogMgr.logWarning(
              "DefaultFKHandler.processResult()", "Processing of rows has been cancelled");
          break;
        }
        int row = ds.addRow();
        ds.setValue(
            row, 0, useColumnNames ? rs.getString("PKTABLE_CAT") : rs.getString(1)); // PKTABLE_CAT
        ds.setValue(
            row,
            1,
            useColumnNames ? rs.getString("PKTABLE_SCHEM") : rs.getString(2)); // PKTABLE_SCHEM
        ds.setValue(
            row,
            2,
            useColumnNames ? rs.getString("PKTABLE_NAME") : rs.getString(3)); // PKTABLE_NAME
        ds.setValue(
            row,
            3,
            useColumnNames ? rs.getString("PKCOLUMN_NAME") : rs.getString(4)); // PKCOLUMN_NAME
        ds.setValue(
            row, 4, useColumnNames ? rs.getString("FKTABLE_CAT") : rs.getString(5)); // FKTABLE_CAT
        ds.setValue(
            row,
            5,
            useColumnNames ? rs.getString("FKTABLE_SCHEM") : rs.getString(6)); // FKTABLE_SCHEM
        ds.setValue(
            row,
            6,
            useColumnNames ? rs.getString("FKTABLE_NAME") : rs.getString(7)); // FKTABLE_NAME
        ds.setValue(
            row,
            7,
            useColumnNames ? rs.getString("FKCOLUMN_NAME") : rs.getString(8)); // FKCOLUMN_NAME
        ds.setValue(
            row,
            8,
            Integer.valueOf(useColumnNames ? rs.getInt("KEY_SEQ") : rs.getInt(9))); // KEY_SEQ

        int updRule = fixRule(useColumnNames ? rs.getInt("UPDATE_RULE") : rs.getInt(10));
        ds.setValue(row, 9, Integer.valueOf(updRule)); // UPDATE_RULE

        int delRule = fixRule(useColumnNames ? rs.getInt("DELETE_RULE") : rs.getInt(11));
        ds.setValue(row, 10, Integer.valueOf(delRule)); // DELETE_RULE
        ds.setValue(
            row, 11, useColumnNames ? rs.getString("FK_NAME") : rs.getString(12)); // FK_NAME
        ds.setValue(
            row, 12, useColumnNames ? rs.getString("PK_NAME") : rs.getString(13)); // PK_NAME

        int defer = fixDeferrableRule(useColumnNames ? rs.getInt("DEFERRABILITY") : rs.getInt(14));
        ds.setValue(row, 13, Integer.valueOf(defer)); // DEFERRABILITY
        if (enabledCol > 0) {
          ds.setValue(row, enabledCol - 1, rs.getString(enabledCol));
          ds.setValue(row, validCol - 1, rs.getString(validCol));
        }
      }
      ds.resetStatus();
    } finally {
      SqlUtil.closeResult(rs);
    }
    return ds;
  }