private Table createTable(Connection conn, ResultSet rs) throws SQLException {
    String realTableName = null;
    try {
      ResultSetMetaData rsMetaData = rs.getMetaData();
      String schemaName = rs.getString("TABLE_SCHEM") == null ? "" : rs.getString("TABLE_SCHEM");
      realTableName = rs.getString("TABLE_NAME");
      String tableType = rs.getString("TABLE_TYPE");
      String remarks = rs.getString("REMARKS");
      if (remarks == null && dbHelper.isOracleDataBase()) {
        remarks = getOracleTableComments(realTableName);
      }

      Table table = new Table();
      table.setSqlName(realTableName);
      table.setRemarks(remarks);

      if ("SYNONYM".equals(tableType) && dbHelper.isOracleDataBase()) {
        table.setOwnerSynonymName(getSynonymOwner(realTableName));
      }

      retriveTableColumns(table);

      table.initExportedKeys(conn.getMetaData());
      table.initImportedKeys(conn.getMetaData());
      BeanHelper.copyProperties(
          table, TableOverrideValuesProvider.getTableOverrideValues(table.getSqlName()));
      return table;
    } catch (SQLException e) {
      throw new RuntimeException("create table object error,tableName:" + realTableName, e);
    }
  }
 private String getSynonymOwner(String synonymName) {
   PreparedStatement ps = null;
   ResultSet rs = null;
   String ret = null;
   try {
     ps =
         getConnection()
             .prepareStatement(
                 "select table_owner from sys.all_synonyms where table_name=? and owner=?");
     ps.setString(1, synonymName);
     ps.setString(2, getSchema());
     rs = ps.executeQuery();
     if (rs.next()) {
       ret = rs.getString(1);
     } else {
       String databaseStructure = getDatabaseStructureInfo();
       throw new RuntimeException(
           "Wow! Synonym " + synonymName + " not found. How can it happen? " + databaseStructure);
     }
   } catch (SQLException e) {
     String databaseStructure = getDatabaseStructureInfo();
     GLogger.error(e.getMessage(), e);
     throw new RuntimeException("Exception in getting synonym owner " + databaseStructure);
   } finally {
     dbHelper.close(rs, ps);
   }
   return ret;
 }
 private String getOracleColumnComments(String table, String column) {
   String sql =
       "SELECT comments FROM user_col_comments WHERE table_name='"
           + table
           + "' AND column_name = '"
           + column
           + "'";
   return dbHelper.queryForString(sql);
 }
  private List getTableColumns(
      Table table, List primaryKeys, List indices, Map uniqueIndices, Map uniqueColumns)
      throws SQLException {
    // get the columns
    List columns = new LinkedList();
    ResultSet columnRs = getColumnsResultSet(table);

    while (columnRs.next()) {
      int sqlType = columnRs.getInt("DATA_TYPE");
      String sqlTypeName = columnRs.getString("TYPE_NAME");
      String columnName = columnRs.getString("COLUMN_NAME");
      String columnDefaultValue = columnRs.getString("COLUMN_DEF");

      String remarks = columnRs.getString("REMARKS");
      if (remarks == null && dbHelper.isOracleDataBase()) {
        remarks = getOracleColumnComments(table.getSqlName(), columnName);
      }

      // if columnNoNulls or columnNullableUnknown assume "not nullable"
      boolean isNullable = (DatabaseMetaData.columnNullable == columnRs.getInt("NULLABLE"));
      int size = columnRs.getInt("COLUMN_SIZE");
      int decimalDigits = columnRs.getInt("DECIMAL_DIGITS");

      boolean isPk = primaryKeys.contains(columnName);
      boolean isIndexed = indices.contains(columnName);
      String uniqueIndex = (String) uniqueIndices.get(columnName);
      List columnsInUniqueIndex = null;
      if (uniqueIndex != null) {
        columnsInUniqueIndex = (List) uniqueColumns.get(uniqueIndex);
      }

      boolean isUnique = columnsInUniqueIndex != null && columnsInUniqueIndex.size() == 1;
      if (isUnique) {
        GLogger.trace("unique column:" + columnName);
      }
      Column column =
          new Column(
              table,
              sqlType,
              sqlTypeName,
              columnName,
              size,
              decimalDigits,
              isPk,
              isNullable,
              isIndexed,
              isUnique,
              columnDefaultValue,
              remarks);
      BeanHelper.copyProperties(
          column, TableOverrideValuesProvider.getColumnOverrideValues(table, column));
      columns.add(column);
    }
    columnRs.close();
    return columns;
  }
  private String getDatabaseStructureInfo() {
    ResultSet schemaRs = null;
    ResultSet catalogRs = null;
    String nl = System.getProperty("line.separator");
    StringBuffer sb = new StringBuffer(nl);
    // Let's give the user some feedback. The exception
    // is probably related to incorrect schema configuration.
    sb.append("Configured schema:").append(getSchema()).append(nl);
    sb.append("Configured catalog:").append(getCatalog()).append(nl);

    try {
      schemaRs = getMetaData().getSchemas();
      sb.append("Available schemas:").append(nl);
      while (schemaRs.next()) {
        sb.append("  ").append(schemaRs.getString("TABLE_SCHEM")).append(nl);
      }
    } catch (SQLException e2) {
      GLogger.warn("Couldn't get schemas", e2);
      sb.append("  ?? Couldn't get schemas ??").append(nl);
    } finally {
      dbHelper.close(schemaRs, null);
    }

    try {
      catalogRs = getMetaData().getCatalogs();
      sb.append("Available catalogs:").append(nl);
      while (catalogRs.next()) {
        sb.append("  ").append(catalogRs.getString("TABLE_CAT")).append(nl);
      }
    } catch (SQLException e2) {
      GLogger.warn("Couldn't get catalogs", e2);
      sb.append("  ?? Couldn't get catalogs ??").append(nl);
    } finally {
      dbHelper.close(catalogRs, null);
    }
    return sb.toString();
  }
 private Table getTable(String catalog, String schema, String tableName) {
   Table t = null;
   try {
     t = _getTable(catalog, schema, tableName);
     if (t == null && !tableName.equals(tableName.toUpperCase())) {
       t = _getTable(catalog, schema, tableName.toUpperCase());
     }
     if (t == null && !tableName.equals(tableName.toLowerCase())) {
       t = _getTable(catalog, schema, tableName.toLowerCase());
     }
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
   if (t == null) {
     throw new NotFoundTableException(
         "not found table with give name:"
             + tableName
             + (dbHelper.isOracleDataBase()
                 ? " \n databaseStructureInfo:" + getDatabaseStructureInfo()
                 : ""));
   }
   return t;
 }
 private String getOracleTableComments(String table) {
   String sql = "SELECT comments FROM user_tab_comments WHERE table_name='" + table + "'";
   return dbHelper.queryForString(sql);
 }
  private void retriveTableColumns(Table table) throws SQLException {
    GLogger.trace("-------setColumns(" + table.getSqlName() + ")");

    List primaryKeys = getTablePrimaryKeys(table);
    table.setPrimaryKeyColumns(primaryKeys);

    // get the indices and unique columns
    List indices = new LinkedList();
    // maps index names to a list of columns in the index
    Map uniqueIndices = new HashMap();
    // maps column names to the index name.
    Map uniqueColumns = new HashMap();
    ResultSet indexRs = null;

    try {

      if (table.getOwnerSynonymName() != null) {
        indexRs =
            getMetaData()
                .getIndexInfo(
                    getCatalog(), table.getOwnerSynonymName(), table.getSqlName(), false, true);
      } else {
        indexRs =
            getMetaData().getIndexInfo(getCatalog(), getSchema(), table.getSqlName(), false, true);
      }
      while (indexRs.next()) {
        String columnName = indexRs.getString("COLUMN_NAME");
        if (columnName != null) {
          GLogger.trace("index:" + columnName);
          indices.add(columnName);
        }

        // now look for unique columns
        String indexName = indexRs.getString("INDEX_NAME");
        boolean nonUnique = indexRs.getBoolean("NON_UNIQUE");

        if (!nonUnique && columnName != null && indexName != null) {
          List l = (List) uniqueColumns.get(indexName);
          if (l == null) {
            l = new ArrayList();
            uniqueColumns.put(indexName, l);
          }
          l.add(columnName);
          uniqueIndices.put(columnName, indexName);
          GLogger.trace("unique:" + columnName + " (" + indexName + ")");
        }
      }
    } catch (Throwable t) {
      // Bug #604761 Oracle getIndexInfo() needs major grants
      // http://sourceforge.net/tracker/index.php?func=detail&aid=604761&group_id=36044&atid=415990
    } finally {
      dbHelper.close(indexRs, null);
    }

    List columns = getTableColumns(table, primaryKeys, indices, uniqueIndices, uniqueColumns);

    for (Iterator i = columns.iterator(); i.hasNext(); ) {
      Column column = (Column) i.next();
      table.addColumn(column);
    }

    // In case none of the columns were primary keys, issue a warning.
    if (primaryKeys.size() == 0) {
      GLogger.warn(
          "WARNING: The JDBC driver didn't report any primary key columns in "
              + table.getSqlName());
    }
  }