public static void main(String[] args) {
    Connection con = null;
    DatabaseMetaData dbmd = null;

    try {
      Class.forName(driver);
      con = DriverManager.getConnection(url);
      System.out.println(con.toString());
      // Use the database connection somehow.

      dbmd = con.getMetaData();

      System.out.println("\n----------------------------------------------------");
      System.out.println("Database Name    = " + dbmd.getDatabaseProductName());
      System.out.println("Database Version = " + dbmd.getDatabaseProductVersion());
      System.out.println("Driver Name      = " + dbmd.getDriverName());
      System.out.println("Driver Version   = " + dbmd.getDriverVersion());
      System.out.println("Database URL     = " + dbmd.getURL());
      System.out.println("----------------------------------------------------");

    } catch (SQLException se) {
      printSQLException(se);
    } catch (ClassNotFoundException e) {
      System.out.println("JDBC Driver " + driver + " not found in CLASSPATH");
    } finally {
      if (con != null) {
        try {
          con.close();
        } catch (SQLException se) {
          printSQLException(se);
        }
      }
    }
  }
 private void logDatabaseInfo() throws ServletException {
   SessionHelper helper = RetsServer.createHelper();
   try {
     Session session = helper.beginSession();
     Connection connection = session.connection();
     DatabaseMetaData metaData = connection.getMetaData();
     LOGGER.info(
         "JDBC Driver info: "
             + metaData.getDriverName()
             + " version "
             + metaData.getDriverVersion());
     LOGGER.info(
         "JDBC DB info: "
             + metaData.getDatabaseProductName()
             + " version "
             + metaData.getDatabaseProductVersion());
   } catch (SQLException e) {
     throw new ServletException("Caught", e);
   } catch (HibernateException e) {
     throw new ServletException("Caught", e);
   } finally {
     try {
       helper.close();
     } catch (HibernateException e) {
       throw new ServletException(e);
     }
   }
 }
 public String getDriverVersion() throws SQLException {
   {
     try {
       return _meta.getDriverVersion();
     } catch (SQLException e) {
       handleException(e);
       throw new AssertionError();
     }
   }
 }
Esempio n. 4
0
  @Signature
  public Memory getMetaData() throws SQLException {
    ArrayMemory r = new ArrayMemory();
    r.refOfIndex("userName").assign(metaData.getUserName());

    r.refOfIndex("driverName").assign(metaData.getDriverName());
    r.refOfIndex("driverVersion").assign(metaData.getDriverVersion());
    r.refOfIndex("databaseName").assign(metaData.getDatabaseProductName());
    r.refOfIndex("databaseVersion").assign(metaData.getDatabaseProductVersion());

    r.refOfIndex("catalogSeparator").assign(metaData.getCatalogSeparator());
    r.refOfIndex("catalogTerm").assign(metaData.getCatalogTerm());
    r.refOfIndex("schemaTerm").assign(metaData.getSchemaTerm());
    r.refOfIndex("procedureTerm").assign(metaData.getProcedureTerm());
    r.refOfIndex("searchStringEscape").assign(metaData.getSearchStringEscape());

    r.refOfIndex("numericFunctions").assign(metaData.getNumericFunctions());
    r.refOfIndex("stringFunctions").assign(metaData.getStringFunctions());
    r.refOfIndex("timeDateFunctions").assign(metaData.getTimeDateFunctions());
    r.refOfIndex("systemFunctions").assign(metaData.getSystemFunctions());

    r.refOfIndex("defaultTransactionIsolation").assign(metaData.getDefaultTransactionIsolation());
    r.refOfIndex("identifierQuoteString").assign(metaData.getIdentifierQuoteString());

    r.refOfIndex("maxBinaryLiteralLength").assign(metaData.getMaxBinaryLiteralLength());
    r.refOfIndex("maxCatalogNameLength").assign(metaData.getMaxCatalogNameLength());
    r.refOfIndex("maxCharLiteralLength").assign(metaData.getMaxCharLiteralLength());
    r.refOfIndex("maxConnections").assign(metaData.getMaxConnections());

    r.refOfIndex("maxColumnNameLength").assign(metaData.getMaxColumnNameLength());
    r.refOfIndex("maxColumnsInGroupBy").assign(metaData.getMaxColumnsInGroupBy());
    r.refOfIndex("maxColumnsInIndex").assign(metaData.getMaxColumnsInIndex());
    r.refOfIndex("maxColumnsInOrderBy").assign(metaData.getMaxColumnsInOrderBy());
    r.refOfIndex("maxColumnsInSelect").assign(metaData.getMaxColumnsInSelect());
    r.refOfIndex("maxColumnsInTable").assign(metaData.getMaxColumnsInTable());

    r.refOfIndex("maxCursorNameLength").assign(metaData.getMaxCursorNameLength());
    r.refOfIndex("maxIndexLength").assign(metaData.getMaxIndexLength());
    r.refOfIndex("maxProcedureNameLength").assign(metaData.getMaxProcedureNameLength());
    r.refOfIndex("maxRowSize").assign(metaData.getMaxRowSize());
    r.refOfIndex("maxSchemaNameLength").assign(metaData.getMaxSchemaNameLength());
    r.refOfIndex("maxStatementLength").assign(metaData.getMaxStatementLength());

    r.refOfIndex("maxTableNameLength").assign(metaData.getMaxTableNameLength());
    r.refOfIndex("maxTablesInSelect").assign(metaData.getMaxTablesInSelect());

    return r.toConstant();
  }
 public DatabaseInfo(DatabaseMetaData metaData) throws SQLException {
   try {
     this.productName = metaData.getDatabaseProductName();
     this.productVersion = metaData.getDatabaseProductVersion();
     this.minorVersion = metaData.getDatabaseMinorVersion();
     this.majorVersion = metaData.getDatabaseMajorVersion();
   } catch (Error e) {
     if (logger.isErrorEnabled()) {
       logger.error(
           (format(
               "JDBC Driver %s version is not applicable for Migrator, use latest version of the driver",
               metaData.getDriverVersion())));
     }
     System.exit(DRIVER_ERROR);
   }
 }
  /**
   * This method creates the real connection to database.
   *
   * @param connInfo connection information like url, username and password
   * @return a connection to the database
   * @throws DatabaseConnectionException if the connection cannot be established.
   */
  protected Connection createConnection(Properties connInfo) throws DatabaseConnectionException {
    try {
      // instantiate the Driver class
      try {
        if (connInfo.get("jdbc_class") != null) {
          Class.forName((String) connInfo.get("jdbc_class")).newInstance();
        }
      } catch (Exception e) {
        throw new DatabaseConnectionException(
            "Cannot load driver class " + connInfo.get("jdbc_class"), e);
      }

      Properties connectionInfo = new Properties();
      if (connInfo.get("jdbc_user") != null) {
        connectionInfo.put("user", connInfo.get("jdbc_user"));
      }
      if (connInfo.get("jdbc_pwd") != null) {
        connectionInfo.put("password", connInfo.get("jdbc_pwd"));
      }
      connectionInfo.put("charSet", "UTF-8");

      Connection conn =
          DriverManager.getConnection((String) connInfo.get("jdbc_url"), connectionInfo);

      // enable transaction support
      conn.setAutoCommit(false);
      conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

      DatabaseMetaData meta = conn.getMetaData();
      logger.info(
          "Connected to "
              + connInfo.get("jdbc_url")
              + ": "
              + meta.getDatabaseProductName()
              + " "
              + meta.getDatabaseProductVersion()
              + " with driver "
              + meta.getDriverName()
              + " "
              + meta.getDriverVersion());

      return conn;
    } catch (SQLException e) {
      throw new DatabaseConnectionException(
          "Unable to create a connection to: " + connInfo.get("jdbc_url"), e);
    }
  }
Esempio n. 7
0
  private void set(DatasourceConnection dc) {
    if (dc != null) {
      datasource = dc.getDatasource();
      try {
        DatabaseMetaData md = dc.getConnection().getMetaData();
        md.getDatabaseProductName();
        setAdditional(KeyImpl.init("DatabaseName"), md.getDatabaseProductName());
        setAdditional(KeyImpl.init("DatabaseVersion"), md.getDatabaseProductVersion());
        setAdditional(KeyImpl.init("DriverName"), md.getDriverName());
        setAdditional(KeyImpl.init("DriverVersion"), md.getDriverVersion());
        // setAdditional("url",md.getURL());

        setAdditional(KeyConstants._Datasource, dc.getDatasource().getName());

      } catch (SQLException e) {
      }
    }
  }
Esempio n. 8
0
 public void init(ConnectionFactory cf) throws DAOException {
   Connection conn = cf.getConnection();
   try {
     DatabaseMetaData dbmd = conn.getMetaData();
     this.setDatabaseProductName(dbmd.getDatabaseProductName());
     this.setDatabaseProductVersion(dbmd.getDatabaseProductVersion());
     this.setDriverName(dbmd.getDriverName());
     this.setDriverVersion(dbmd.getDriverVersion());
   } catch (SQLException e) {
     throw (new DAOException(e));
   } finally {
     try {
       conn.close();
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }
 protected void setupConnectionMetaInfo(Connection conn) throws SQLException {
   try {
     final DfConnectionMetaInfo metaInfo = new DfConnectionMetaInfo();
     final DatabaseMetaData metaData = conn.getMetaData();
     metaInfo.setProductName(metaData.getDatabaseProductName());
     metaInfo.setProductVersion(metaData.getDatabaseProductVersion());
     metaInfo.setDriverName(metaData.getDriverName());
     metaInfo.setDriverVersion(metaData.getDriverVersion());
     final int majorVersion = metaData.getJDBCMajorVersion();
     final int minorVersion = metaData.getJDBCMinorVersion();
     metaInfo.setJdbcVersion(majorVersion + "." + minorVersion);
     _log.info("  product = " + metaInfo.getProductDisp());
     _log.info("  driver  = " + metaInfo.getDriverDisp());
     _connectionMetaInfo = metaInfo;
   } catch (SQLException continued) {
     _log.info("*Failed to get connection meta: " + continued.getMessage());
     _connectionMetaInfo = null;
   }
 }
  @RequestMapping(method = RequestMethod.GET)
  public String showInformations(Model model) {
    List<Informations> info = new ArrayList<>();
    info.add(new Informations("Versão", repInfo.getProperty("repository.version")));
    info.add(new Informations("Número de documentos", Long.toString(docService.count())));

    info.add(
        new Informations(
            "Domínio",
            config.getProperty("Repositorio.hostname"),
            "Este dominio será utilizado para criar a localização dos documentos. Editar no arquivo: 'config.properties'."));
    info.add(
        new Informations(
            "Raiz do projeto", config.getProperty("Repositorio.rootPath", "/repositorio")));
    info.add(
        new Informations(
            "Porta",
            config.getProperty("Repositorio.port", "8080"),
            "Porta informada no arquivo '/WEB-INF/classes/config.properties'"));
    info.add(
        new Informations(
            "URL dos objetos",
            Config.getUrl(config) + "{id}",
            "URL que será utilizada para criar o location dos objetos. Pode ser editada em: '/WEB-INF/classes/config.properties'"));
    try {
      DatabaseMetaData databaseInfo = dataSource.getConnection().getMetaData();
      info.add(new Informations("Base de dados utilizada", databaseInfo.getDatabaseProductName()));
      info.add(
          new Informations("Versão da base de dados", databaseInfo.getDatabaseProductVersion()));
      info.add(new Informations("JDBC driver", databaseInfo.getDriverName()));
      info.add(new Informations("Versão do JDBC driver", databaseInfo.getDriverVersion()));
      info.add(new Informations("URL da base de dados", databaseInfo.getURL()));
      info.add(new Informations("Usuário da base de dados", databaseInfo.getUserName()));

    } catch (SQLException s) {
      log.error("Error getting information about database.", s);
      info.add(new Informations("Erro", "Não foi possível carregar os dados da base de dados"));
    }
    model.addAttribute("info", info);
    return "panel/show";
  }
Esempio n. 11
0
 private static Map<PwmAboutProperty, String> getConnectionDebugProperties(
     final Connection connection) {
   if (connection != null) {
     try {
       final Map<PwmAboutProperty, String> returnObj = new LinkedHashMap<>();
       final DatabaseMetaData databaseMetaData = connection.getMetaData();
       returnObj.put(PwmAboutProperty.database_driverName, databaseMetaData.getDriverName());
       returnObj.put(PwmAboutProperty.database_driverVersion, databaseMetaData.getDriverVersion());
       returnObj.put(
           PwmAboutProperty.database_databaseProductName,
           databaseMetaData.getDatabaseProductName());
       returnObj.put(
           PwmAboutProperty.database_databaseProductVersion,
           databaseMetaData.getDatabaseProductVersion());
       return Collections.unmodifiableMap(returnObj);
     } catch (SQLException e) {
       LOGGER.error("error rading jdbc meta data: " + e.getMessage());
     }
   }
   return Collections.emptyMap();
 }
  /** Learn relevant information about this connection source. */
  public void discoverConnectionProperties() {
    Connection connection = null;
    try {
      connection = getConnection();
      if (connection == null) {
        addWarn("Could not get a connection");
        return;
      }
      DatabaseMetaData meta = connection.getMetaData();
      DBUtil util = new DBUtil();
      util.setContext(getContext());
      supportsGetGeneratedKeys = util.supportsGetGeneratedKeys(meta);
      supportsBatchUpdates = util.supportsBatchUpdates(meta);
      dialectCode = DBUtil.discoverSQLDialect(meta);
      addInfo("Driver name=" + meta.getDriverName());
      addInfo("Driver version=" + meta.getDriverVersion());
      addInfo("supportsGetGeneratedKeys=" + supportsGetGeneratedKeys);

    } catch (SQLException se) {
      addWarn("Could not discover the dialect to use.", se);
    } finally {
      DBHelper.closeConnection(connection);
    }
  }
Esempio n. 13
0
  public void init() throws ServletException {
    super.init();

    ARE.getLog()
        .info(
            "**********************************InitDataServlet Start*********************************");
    try {
      ARE.getLog()
          .info(
              "**============System  Property Begin==============================================**");
      Properties ps = System.getProperties();
      Iterator ir = ps.keySet().iterator();
      for (int i = 1; ir.hasNext(); i++) {
        String sKey = (String) ir.next();
        ARE.getLog().info("(" + i + ")" + sKey + " = [" + ps.getProperty(sKey) + "]");
      }
      ARE.getLog()
          .info(
              "**============System  Property End=================================================**");

      Transaction Sqlca = null;
      try {
        String sConfigFile = getInitParameter("ConfigFile");
        if ((sConfigFile != null) && (!"".equals(sConfigFile))) {
          ASConfigure.setXMLFile(sConfigFile);
          ARE.getLog().info("ConfigFile       = [" + sConfigFile + "]");
        }

        ASConfigure asc = ASConfigure.getASConfigure(getServletContext());
        Sqlca = getSqlca(asc);
        ARE.getLog()
            .info(
                "**============DataBase And JDBC Property Begin=====================================**");
        DatabaseMetaData dbmd = Sqlca.conn.getMetaData();
        ARE.getLog()
            .info(
                "DatabaseName["
                    + dbmd.getDatabaseProductName()
                    + "]  Version["
                    + dbmd.getDatabaseProductVersion()
                    + "]");
        ARE.getLog()
            .info(
                "Driver Name["
                    + dbmd.getDriverName()
                    + "]  Version["
                    + dbmd.getDriverVersion()
                    + "]");
        ARE.getLog()
            .info(
                "JDBC MajorVersion["
                    + dbmd.getJDBCMajorVersion()
                    + "] MinorVersion["
                    + dbmd.getJDBCMinorVersion()
                    + "]");
        ARE.getLog().info("URL[" + dbmd.getURL() + "] UserName[" + dbmd.getUserName() + "]");
        ARE.getLog()
            .info(
                "DatabaseState IsAutoCommit["
                    + Sqlca.conn.getAutoCommit()
                    + "] TransactionIsolation["
                    + Sqlca.conn.getTransactionIsolation()
                    + "]");
        ARE.getLog()
            .info(
                "**============DataBase And JDBC Property End=======================================**");

        ARE.getLog()
            .info("Init Cache Data[ALL]            .......... Starting" + StringFunction.getNow());
        ASConfigure.getSysConfig("ASCodeSet", Sqlca);
        ARE.getLog()
            .info("Init Cache Data[SYSCONFIG_CODE] .......... Success!" + StringFunction.getNow());
        ASConfigure.getSysConfig("ASCompSet", Sqlca);
        ARE.getLog()
            .info("Init Cache Data[SYSCONFIG_COMP] .......... Success!" + StringFunction.getNow());
        ASConfigure.getSysConfig("ASFuncSet", Sqlca);
        ARE.getLog()
            .info("Init Cache Data[SYSCONFIG_FUNC] .......... Success!" + StringFunction.getNow());
        ASConfigure.getSysConfig("ASRoleSet", Sqlca);
        ARE.getLog()
            .info("Init Cache Data[SYSCONFIG_ROLE] .......... Success!" + StringFunction.getNow());
        ARE.getLog()
            .info("Init Cache Data[ALL]            .......... Success!" + StringFunction.getNow());
      } catch (Exception e) {
        ARE.getLog().info("InitDataServerlet :error", e);
        e.printStackTrace();
        throw new RuntimeException("构造系统配置时出错:" + e);
      } finally {
        try {
          if (Sqlca != null) {
            Sqlca.conn.commit();
            Sqlca.disConnect();
            Sqlca = null;
          }
        } catch (Exception e1) {
        }
      }
    } catch (Exception e) {
      ARE.getLog().info("InitDataServerlet :error", e);
      e.printStackTrace();
    }
    ARE.getLog()
        .info(
            "**********************************InitDataServlet Success*********************************");
    ARE.getLog().info("");
  }
Esempio n. 14
0
    @Override
    public IStatus run(DBRProgressMonitor monitor) {
      if (ownerMonitor != null) {
        monitor = ownerMonitor;
      }
      monitor.beginTask(CoreMessages.dialog_connection_wizard_start_connection_monitor_start, 4);
      Thread.currentThread()
          .setName(CoreMessages.dialog_connection_wizard_start_connection_monitor_thread);

      try {
        container.setName(container.getConnectionConfiguration().getUrl());
        monitor.worked(1);
        long startTime = System.currentTimeMillis();
        super.run(monitor);
        connectTime = (System.currentTimeMillis() - startTime);
        if (connectError != null || monitor.isCanceled()) {
          return Status.OK_STATUS;
        }

        monitor.worked(1);
        DBPDataSource dataSource = container.getDataSource();
        if (dataSource == null) {
          throw new DBException(CoreMessages.editors_sql_status_not_connected_to_database);
        }
        //                monitor.subTask("Initialize connection");
        //                dataSource.initialize(monitor);
        //                monitor.worked(1);
        monitor.subTask(
            CoreMessages.dialog_connection_wizard_start_connection_monitor_subtask_test);

        DBPDataSourceInfo info = dataSource.getInfo();
        if (info != null) {
          try {
            productName = info.getDatabaseProductName();
            productVersion = info.getDatabaseProductVersion();
            driverName = info.getDriverName();
            driverVersion = info.getDriverVersion();
          } catch (Exception e) {
            log.error("Can't obtain connection metadata", e);
          }
        } else {
          try (DBCSession session =
              DBUtils.openUtilSession(monitor, dataSource, "Test connection")) {
            if (session instanceof Connection) {
              try {
                Connection connection = (Connection) session;
                DatabaseMetaData metaData = connection.getMetaData();
                productName = metaData.getDatabaseProductName();
                productVersion = metaData.getDatabaseProductVersion();
                driverName = metaData.getDriverName();
                driverVersion = metaData.getDriverVersion();
              } catch (Exception e) {
                log.error("Can't obtain connection metadata", e);
              }
            }
          }
        }
        new DisconnectJob(container).schedule();
        monitor.subTask(CoreMessages.dialog_connection_wizard_start_connection_monitor_success);
      } catch (DBException ex) {
        connectError = ex;
      }
      monitor.done();
      return Status.OK_STATUS;
    }
Esempio n. 15
0
  public void actionPerformed(ActionEvent e) {
    switch (pos) {
      case 0:
        try {
          btnNext.setEnabled(false);
          btnPrev.setEnabled(true);

          Class.forName(pnlDStarget.getDriver());
          dbConnTarget =
              DriverManager.getConnection(
                  pnlDStarget.getUrl(), pnlDStarget.getUser(), pnlDStarget.getPasswd());

          cardL.show(pnlContent, "DS_TARGET_MSG");
          DatabaseMetaData dbMeta = dbConnTarget.getMetaData();

          jtaMsgTarget.setText(null);
          jtaMsgTarget.append(
              "Connected to "
                  + dbMeta.getDatabaseProductName()
                  + " version "
                  + dbMeta.getDatabaseProductVersion()
                  + "\r\n");
          jtaMsgTarget.append(
              "Using driver "
                  + dbMeta.getDriverName()
                  + " version "
                  + dbMeta.getDriverVersion()
                  + "\r\n");
          jtaMsgTarget.append("Catalog term is " + dbMeta.getCatalogTerm() + "\r\n");
          jtaMsgTarget.append("Schema term is " + dbMeta.getSchemaTerm() + "\r\n");
          jtaMsgTarget.append("Connection to datasource successfully!");
          btnNext.setEnabled(true);
          btnPrev.setEnabled(true);
        } catch (SQLException ex) {
          ex.printStackTrace();
          return;
        } catch (ClassNotFoundException ex) {
          ex.printStackTrace();
          return;
        }
        pos++;
        break;

      case 1:
        if (e.getActionCommand().equals("NEXT")) {
          cardL.show(pnlContent, "DB_OPEN_FILE");
          pos++;
        } else {

        }
        break;

      case 2:
        if (e.getActionCommand().equals("NEXT")) {
          backupDiffLoader = new BackupLoaderPanel(rlp.getFileName());
          pnlContent.add(backupDiffLoader, "DB_BACKUP_LOADER");
          cardL.show(pnlContent, "DB_BACKUP_LOADER");
          pos++;
          backupDiffLoader.actionPerformed(null);
        } else {

        }
        break;

      case 3:
        if (e.getActionCommand().equals("NEXT")) {
          structDiffWriter =
              new StructDiffWriterPanel(dbConnTarget, backupDiffLoader.getDiffStmtList());
          pnlContent.add(structDiffWriter, "DB_STRUCT_DIFF");
          cardL.show(pnlContent, "DB_STRUCT_DIFF");
          pos++;
          structDiffWriter.actionPerformed(null);
        } else {

        }
        break;

      case 4:
        if (e.getActionCommand().equals("NEXT")) {
          dbPanelTarget = new DBTreeBuilderPanel(dbConnTarget, null, "public");
          pnlContent.add(dbPanelTarget, "DB_BUILDER_TARGET");
          cardL.show(pnlContent, "DB_BUILDER_TARGET");
          pos++;
          dbPanelTarget.actionPerformed(null);
        } else {

        }
        break;

      case 5:
        if (e.getActionCommand().equals("NEXT")) {
          DataDiffWriterPanel dataDiffWriter =
              new DataDiffWriterPanel(
                  dbConnTarget,
                  dbPanelTarget.getTableList(),
                  backupDiffLoader.getDbIncrementalData());
          pnlContent.add(dataDiffWriter, "DB_DATA_DIFF");
          cardL.show(pnlContent, "DB_DATA_DIFF");
          pos++;
          dataDiffWriter.actionPerformed(null);
        } else {

        }
        dbPanelTarget.getTableList();
        break;
    }
  }
Esempio n. 16
0
  public JSONObject execute(
      HttpServletRequest request,
      HttpServletResponse response,
      EntityManager em,
      EntityTransaction et)
      throws Exception {
    DatabaseNode dn = (DatabaseNode) IDManager.get().get(id);
    JSONObject results = new JSONObject();
    JSONArray meta = new JSONArray();
    JSONArray data = new JSONArray();

    String[] strs = {"Property", "Value"};

    for (int i = 0; i < strs.length; i++) {
      meta.put(strs[i]);
    }

    SQLDatabaseMetaData metaData = dn.getConn().getSQLMetaData();
    DatabaseMetaData jdbcmetadata = metaData.getJDBCMetaData();
    JSONArray record = new JSONArray();
    record.put("Database Product Name");
    try {
      record.put(metaData.getDatabaseProductName());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Database Product Version");
    try {
      record.put(metaData.getDatabaseProductVersion());

    } catch (Throwable e) {
      record.put("Unsupported");
    }

    data.put(record);

    record = new JSONArray();
    record.put("Driver Major Version");
    try {
      record.put(jdbcmetadata.getDriverMajorVersion());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Driver Minor Version");
    try {
      record.put(jdbcmetadata.getDriverMinorVersion());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Driver Name");
    try {
      record.put(metaData.getDriverName());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Driver Version");
    try {
      record.put(jdbcmetadata.getDriverVersion());
    } catch (Throwable e) {
      record.put("Unsupported");
    }

    data.put(record);

    record = new JSONArray();
    record.put("Username");
    try {
      record.put(metaData.getUserName());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("URL");
    try {
      record.put(jdbcmetadata.getURL());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    //		record=new JSONArray();
    //		record.put("Auto Commit");
    //		try{
    //			record.put(dn.getConn().getAutoCommit());
    //
    //		}catch(Throwable e){record.put("Unsupported");}
    //		data.put(record);

    record = new JSONArray();
    record.put("All Procedures Are Callable");
    try {
      record.put(jdbcmetadata.allProceduresAreCallable());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("All Tables Are Selectable");
    try {
      record.put(jdbcmetadata.allTablesAreSelectable());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Nulls are sorted High");
    try {
      record.put(jdbcmetadata.nullsAreSortedHigh());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Nulls are sorted Low");
    try {
      record.put(jdbcmetadata.nullsAreSortedLow());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Nulls are sorted at Start");
    try {
      record.put(jdbcmetadata.nullsAreSortedAtStart());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Nulls are sorted at End");
    try {
      record.put(jdbcmetadata.nullsAreSortedAtEnd());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Is Read Only");
    try {
      record.put(jdbcmetadata.isReadOnly());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Result Set Holdability");
    try {
      record.put(jdbcmetadata.getResultSetHoldability());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Uses Local Files");
    try {
      record.put(jdbcmetadata.usesLocalFiles());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Uses Local File per Table");

    try {
      record.put(jdbcmetadata.usesLocalFilePerTable());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Mixed Case Identifiers");

    try {
      record.put(jdbcmetadata.supportsMixedCaseIdentifiers());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Stores Upper Case Identifiers");

    try {
      record.put(jdbcmetadata.storesUpperCaseIdentifiers());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Stores Lower Case Identifiers");
    try {
      record.put(jdbcmetadata.storesLowerCaseIdentifiers());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Stores Mixed Case Identifiers");
    try {
      record.put(jdbcmetadata.storesMixedCaseIdentifiers());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Mixed Case Quoted Identifiers");
    try {
      record.put(jdbcmetadata.supportsMixedCaseQuotedIdentifiers());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Stores Upper Case Quoted Identifiers");

    try {
      record.put(jdbcmetadata.storesUpperCaseQuotedIdentifiers());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Stores Lower Case Quoted Identifiers");

    try {
      record.put(jdbcmetadata.storesLowerCaseQuotedIdentifiers());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Stores Mixed Case Quoted Identifiers");
    try {
      record.put(jdbcmetadata.storesMixedCaseQuotedIdentifiers());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Identifier Quote");
    try {
      record.put(jdbcmetadata.getIdentifierQuoteString());
    } catch (Throwable e) {
    }
    data.put(record);

    record = new JSONArray();
    record.put("Search String Escape");
    try {
      record.put(jdbcmetadata.getSearchStringEscape());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Extra Name Characters");
    try {
      record.put(jdbcmetadata.getExtraNameCharacters());

    } catch (Throwable e) {
      record.put("Unsupported");
    }

    data.put(record);

    record = new JSONArray();
    record.put("Supports Alter Table With Add Column");
    try {
      record.put(jdbcmetadata.supportsAlterTableWithAddColumn());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Alter Table With Drop Column");
    try {

      record.put(jdbcmetadata.supportsAlterTableWithDropColumn());

    } catch (Throwable e) {
      record.put("Unsupported");
    }

    data.put(record);

    record = new JSONArray();
    record.put("Supports Column Aliasing");
    try {

      record.put(jdbcmetadata.supportsColumnAliasing());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Null Plus Non Null Is Null");
    try {

      record.put(jdbcmetadata.nullPlusNonNullIsNull());

    } catch (Throwable e) {
      record.put("Unsupported");
    }

    data.put(record);

    record = new JSONArray();
    record.put("Supports Convert");
    try {

      record.put(jdbcmetadata.supportsConvert());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Table Correlation Names");
    try {

      record.put(jdbcmetadata.supportsTableCorrelationNames());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Expressions in Order By");
    try {

      record.put(jdbcmetadata.supportsExpressionsInOrderBy());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Order By Unrelated");
    try {

      record.put(jdbcmetadata.supportsOrderByUnrelated());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Group By");
    try {

      record.put(jdbcmetadata.supportsGroupBy());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Group By Unrelated");
    try {

      record.put(jdbcmetadata.supportsGroupByUnrelated());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Group By Beyond Select");
    try {
      record.put(jdbcmetadata.supportsGroupByBeyondSelect());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Like Escape Clause");
    try {
      record.put(jdbcmetadata.supportsLikeEscapeClause());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Multiple Result Sets");
    try {
      record.put(jdbcmetadata.supportsMultipleResultSets());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Multiple Open Results");
    try {
      record.put(jdbcmetadata.supportsMultipleOpenResults());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Multiple Transactions");
    try {

      record.put(jdbcmetadata.supportsMultipleTransactions());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Non Nullable Columns");
    try {
      record.put(jdbcmetadata.supportsNonNullableColumns());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Minimum SQL Grammar");
    try {
      record.put(jdbcmetadata.supportsMinimumSQLGrammar());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Core SQL Grammar");
    try {
      record.put(jdbcmetadata.supportsCoreSQLGrammar());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Extended SQL Grammar");
    try {

      record.put(jdbcmetadata.supportsExtendedSQLGrammar());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports ANSI92 Entry Level SQL");
    try {
      record.put(jdbcmetadata.supportsANSI92EntryLevelSQL());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports ANSI92 Intermediate SQL");
    try {

      record.put(jdbcmetadata.supportsANSI92IntermediateSQL());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports ANSI92 Full SQL");
    try {

      record.put(jdbcmetadata.supportsANSI92FullSQL());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Integrity Enhancement Facility");
    try {

      record.put(jdbcmetadata.supportsIntegrityEnhancementFacility());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Outer Joins");
    try {

      record.put(jdbcmetadata.supportsOuterJoins());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Full Outer Joins");
    try {

      record.put(jdbcmetadata.supportsFullOuterJoins());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Limited Outer Joins");
    try {
      record.put(jdbcmetadata.supportsLimitedOuterJoins());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Schema Term");
    try {
      record.put(jdbcmetadata.getSchemaTerm());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Procedure Term");
    try {
      record.put(jdbcmetadata.getProcedureTerm());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Catalog Term");
    try {
      record.put(jdbcmetadata.getCatalogTerm());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Is Catalog at Start");
    try {
      record.put(jdbcmetadata.isCatalogAtStart());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Catalog Separator");
    try {
      record.put(jdbcmetadata.getCatalogSeparator());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Schemas In Data Manipulation");
    try {
      record.put(jdbcmetadata.supportsSchemasInDataManipulation());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Schemas In Procedure Calls");
    try {
      record.put(jdbcmetadata.supportsSchemasInProcedureCalls());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Schemas In Table Definitions");
    try {
      record.put(jdbcmetadata.supportsSchemasInTableDefinitions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Schemas In Index Definitions");
    try {
      record.put(jdbcmetadata.supportsSchemasInIndexDefinitions());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Schemas In Privilege Definitions");
    try {
      record.put(jdbcmetadata.supportsSchemasInPrivilegeDefinitions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Catalogs In Data Manipulation");
    try {
      record.put(jdbcmetadata.supportsCatalogsInDataManipulation());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Catalogs In Procedure Calls");
    try {
      record.put(jdbcmetadata.supportsCatalogsInProcedureCalls());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Catalogs In Table Definitions");
    try {
      record.put(jdbcmetadata.supportsCatalogsInTableDefinitions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Catalogs In Index Definitions");
    try {
      record.put(jdbcmetadata.supportsCatalogsInIndexDefinitions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Catalogs In Privilege Definitions");
    try {
      record.put(jdbcmetadata.supportsCatalogsInPrivilegeDefinitions());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Positioned Delete");
    try {
      record.put(jdbcmetadata.supportsPositionedDelete());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Positioned Update");
    try {
      record.put(jdbcmetadata.supportsPositionedUpdate());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Select For Update");
    try {
      record.put(jdbcmetadata.supportsSelectForUpdate());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Stored Procedures");
    try {
      record.put(jdbcmetadata.supportsStoredProcedures());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Subqueries In Comparisons");

    try {
      record.put(jdbcmetadata.supportsSubqueriesInComparisons());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Subqueries In Exists");
    try {
      record.put(jdbcmetadata.supportsSubqueriesInExists());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Subqueries in IN Statements");
    try {
      record.put(jdbcmetadata.supportsSubqueriesInIns());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Correlated Subqueries");
    try {
      record.put(jdbcmetadata.supportsCorrelatedSubqueries());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Union");
    try {
      record.put(jdbcmetadata.supportsUnion());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Union All");
    try {
      record.put(jdbcmetadata.supportsUnionAll());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Open Cursors Across Commit");
    try {
      record.put(jdbcmetadata.supportsOpenCursorsAcrossCommit());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Open Cursors Across Rollback");
    try {
      record.put(jdbcmetadata.supportsOpenCursorsAcrossRollback());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Open Statements Across Commit");
    try {
      record.put(jdbcmetadata.supportsOpenStatementsAcrossCommit());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Open Statements Across Rollback");
    try {
      record.put(jdbcmetadata.supportsOpenStatementsAcrossRollback());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Binary Literal Length");
    try {
      record.put(jdbcmetadata.getMaxBinaryLiteralLength());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Char Literal Length");
    try {
      record.put(jdbcmetadata.getMaxCharLiteralLength());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Column Name Length");
    try {
      record.put(jdbcmetadata.getMaxColumnNameLength());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Columns In Group By");
    try {
      record.put(jdbcmetadata.getMaxColumnsInGroupBy());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Columns In Index");
    try {
      record.put(jdbcmetadata.getMaxColumnsInIndex());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Columns In Order By");
    try {
      record.put(jdbcmetadata.getMaxColumnsInOrderBy());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Columns In Select");
    try {

      record.put(jdbcmetadata.getMaxColumnsInSelect());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Columns In Table");
    try {

      record.put(jdbcmetadata.getMaxColumnsInTable());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Connections");
    try {
      record.put(jdbcmetadata.getMaxConnections());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Cursor Name Length");
    try {
      record.put(jdbcmetadata.getMaxCursorNameLength());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Index Length");
    try {
      record.put(jdbcmetadata.getMaxIndexLength());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Schema Name Length");
    try {
      record.put(jdbcmetadata.getMaxSchemaNameLength());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Procedure Name Length");
    try {

      record.put(jdbcmetadata.getMaxProcedureNameLength());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Catalog Name Length");
    try {

      record.put(jdbcmetadata.getMaxCatalogNameLength());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Row Size");
    try {

      record.put(jdbcmetadata.getMaxRowSize());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Row Size Include Blobs");
    try {

      record.put(jdbcmetadata.doesMaxRowSizeIncludeBlobs());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Statement Length");
    try {

      record.put(jdbcmetadata.getMaxStatementLength());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Statements");
    try {
      record.put(jdbcmetadata.getMaxStatements());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Table Name Length");
    try {
      record.put(jdbcmetadata.getMaxTableNameLength());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max Tables In Select");
    try {
      record.put(jdbcmetadata.getMaxTablesInSelect());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Max User Name Length");
    try {
      record.put(jdbcmetadata.getMaxUserNameLength());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Default Transaction Isolation");
    try {

      int isol = jdbcmetadata.getDefaultTransactionIsolation();
      String is = null;
      switch (isol) {
        case java.sql.Connection.TRANSACTION_NONE:
          {
            is = "TRANSACTION_NONE";
            break;
          }
        case java.sql.Connection.TRANSACTION_READ_COMMITTED:
          {
            is = "TRANSACTION_READ_COMMITTED";
            break;
          }
        case java.sql.Connection.TRANSACTION_READ_UNCOMMITTED:
          {
            is = "TRANSACTION_READ_UNCOMMITTED";
            break;
          }
        case java.sql.Connection.TRANSACTION_REPEATABLE_READ:
          {
            is = "TRANSACTION_REPEATABLE_READ";
            break;
          }
        case java.sql.Connection.TRANSACTION_SERIALIZABLE:
          {
            is = "TRANSACTION_SERIALIZABLE";
            break;
          }
        default:
          {
            is = "";
            break;
          }
      }
      record.put(is);

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Transactions");
    try {
      record.put(jdbcmetadata.supportsTransactions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Data Definition and Data Manipulation Transactions");
    try {
      record.put(jdbcmetadata.supportsDataDefinitionAndDataManipulationTransactions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Different Table Correlation Names");
    try {
      record.put(jdbcmetadata.supportsDifferentTableCorrelationNames());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Data Manipulation Transactions Only");
    try {
      record.put(jdbcmetadata.supportsDataManipulationTransactionsOnly());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Data Definition Causes Transaction Commit");
    try {
      record.put(jdbcmetadata.dataDefinitionCausesTransactionCommit());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Data Definition Ignored in Transactions");
    try {
      record.put(jdbcmetadata.dataDefinitionIgnoredInTransactions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Batch Updates");
    try {
      record.put(jdbcmetadata.supportsBatchUpdates());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Savepoints");
    try {
      record.put(jdbcmetadata.supportsSavepoints());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Named Parameters");
    try {
      record.put(jdbcmetadata.supportsNamedParameters());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Get Generated Keys");
    try {
      record.put(jdbcmetadata.supportsGetGeneratedKeys());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Database Major Version");
    try {
      record.put(jdbcmetadata.getDatabaseMajorVersion());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Database Minor Version");
    try {
      record.put(jdbcmetadata.getDatabaseMinorVersion());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("JDBC Minor Version");
    try {
      record.put(jdbcmetadata.getJDBCMinorVersion());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("JDBC Major Version");
    try {
      record.put(jdbcmetadata.getJDBCMajorVersion());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("SQL State Type");
    try {
      int sqlStateType = jdbcmetadata.getSQLStateType();
      String is = null;
      switch (sqlStateType) {
        case DatabaseMetaData.sqlStateXOpen:
          {
            is = "sqlStateXOpen";
            break;
          }
        case DatabaseMetaData.sqlStateSQL:
          {
            is = "sqlStateSQL";
            break;
          }
        default:
          is = "";
      }
      record.put(is);

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Locators Update Copy");
    try {
      record.put(jdbcmetadata.locatorsUpdateCopy());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Statement Pooling");
    try {
      record.put(jdbcmetadata.supportsStatementPooling());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("SQL Keywords");
    try {

      record.put(jdbcmetadata.getSQLKeywords());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Numeric Functions");
    try {
      record.put(jdbcmetadata.getNumericFunctions());

    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("String Functions");
    try {
      record.put(jdbcmetadata.getStringFunctions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("System Functions");
    try {
      record.put(jdbcmetadata.getSystemFunctions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Time and Date Functions");
    try {
      record.put(jdbcmetadata.getTimeDateFunctions());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Auto Commit Failure Closes All ResultSets");
    try {
      record.put(jdbcmetadata.autoCommitFailureClosesAllResultSets());
    } catch (Throwable e) {
      record.put("Unsupported");
    }

    data.put(record);

    record = new JSONArray();
    record.put("Supports Stored Functions Using Call Syntax");
    try {
      record.put(jdbcmetadata.supportsStoredFunctionsUsingCallSyntax());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Supports Subqueries in Quantified Expressions");
    try {
      record.put(jdbcmetadata.supportsSubqueriesInQuantifieds());
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("Client Info Properties");
    try {
      ResultSet rs = jdbcmetadata.getClientInfoProperties();
      while (rs.next()) {
        rs.getString("NAME");
      }
      rs.close();
    } catch (Throwable e) {
      record.put("Unsupported");
    }
    data.put(record);

    record = new JSONArray();
    record.put("ROWID Lifetime");
    try {
      RowIdLifetime rid = jdbcmetadata.getRowIdLifetime();
      if (rid.equals(RowIdLifetime.ROWID_UNSUPPORTED)) record.put("ROWID_UNSUPPORTED");
      else if (rid.equals(RowIdLifetime.ROWID_VALID_FOREVER)) record.put("ROWID_VALID_FOREVER");
      else if (rid.equals(RowIdLifetime.ROWID_VALID_OTHER)) record.put("ROWID_VALID_OTHER");
      else if (rid.equals(RowIdLifetime.ROWID_VALID_SESSION)) record.put("ROWID_VALID_SESSION");
      else if (rid.equals(RowIdLifetime.ROWID_VALID_TRANSACTION))
        record.put("ROWID_VALID_TRANSACTION");
      else record.put("");
    } catch (Throwable e) {
      record.put("Unsupported");
    }

    data.put(record);

    results.put("meta", meta);
    results.put("data", data);
    return results;
  }
  public void testMetaData() {

    String ddl0 =
        "DROP TABLE ADDRESSBOOK IF EXISTS; DROP TABLE ADDRESSBOOK_CATEGORY IF EXISTS; DROP TABLE USER IF EXISTS;";
    String ddl1 =
        "CREATE TABLE USER(USER_ID INTEGER NOT NULL PRIMARY KEY,LOGIN_ID VARCHAR(128) NOT NULL,USER_NAME VARCHAR(254) DEFAULT ' ' NOT NULL,CREATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,UPDATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,LAST_ACCESS_DATE TIMESTAMP,CONSTRAINT IXUQ_LOGIN_ID0 UNIQUE(LOGIN_ID))";
    String ddl2 =
        "CREATE TABLE ADDRESSBOOK_CATEGORY(USER_ID INTEGER NOT NULL,CATEGORY_ID INTEGER DEFAULT 0 NOT NULL,CATEGORY_NAME VARCHAR(60) DEFAULT '' NOT NULL,CONSTRAINT SYS_PK_ADDRESSBOOK_CATEGORY PRIMARY KEY(USER_ID,CATEGORY_ID),CONSTRAINT FK_ADRBKCAT1 FOREIGN KEY(USER_ID) REFERENCES USER(USER_ID) ON DELETE CASCADE)";
    String ddl3 =
        "CREATE TABLE ADDRESSBOOK(USER_ID INTEGER NOT NULL,ADDRESSBOOK_ID INTEGER NOT NULL,CATEGORY_ID INTEGER DEFAULT 0 NOT NULL,FIRST VARCHAR(64) DEFAULT '' NOT NULL,LAST VARCHAR(64) DEFAULT '' NOT NULL,NOTE VARCHAR(128) DEFAULT '' NOT NULL,CONSTRAINT SYS_PK_ADDRESSBOOK PRIMARY KEY(USER_ID,ADDRESSBOOK_ID),CONSTRAINT FK_ADRBOOK1 FOREIGN KEY(USER_ID,CATEGORY_ID) REFERENCES ADDRESSBOOK_CATEGORY(USER_ID,CATEGORY_ID) ON DELETE CASCADE)";
    String result1 = "1";
    String result2 = "2";
    String result3 = "3";
    String result4 = "4";
    String result5 = "5";

    try {
      stmnt.execute(ddl0);
      stmnt.execute(ddl1);
      stmnt.execute(ddl2);
      stmnt.execute(ddl3);

      DatabaseMetaData md = connection.getMetaData();

      {
        System.out.println("Testing DatabaseMetaData methods");
        System.out.println(md.getDatabaseMajorVersion());
        System.out.println(md.getDatabaseMinorVersion());
        System.out.println(md.getDatabaseProductName());
        System.out.println(md.getDatabaseProductVersion());
        System.out.println(md.getDefaultTransactionIsolation());
        System.out.println(md.getDriverMajorVersion());
        System.out.println(md.getDriverMinorVersion());
        System.out.println(md.getDriverName());
        System.out.println(md.getDriverVersion());
        System.out.println(md.getExtraNameCharacters());
        System.out.println(md.getIdentifierQuoteString());
        System.out.println(md.getJDBCMajorVersion());
        System.out.println(md.getJDBCMinorVersion());
        System.out.println(md.getMaxBinaryLiteralLength());
        System.out.println(md.getMaxCatalogNameLength());
        System.out.println(md.getMaxColumnsInGroupBy());
        System.out.println(md.getMaxColumnsInIndex());
        System.out.println(md.getMaxColumnsInOrderBy());
        System.out.println(md.getMaxColumnsInSelect());
        System.out.println(md.getMaxColumnsInTable());
        System.out.println(md.getMaxConnections());
        System.out.println(md.getMaxCursorNameLength());
        System.out.println(md.getMaxIndexLength());
        System.out.println(md.getMaxProcedureNameLength());
        System.out.println(md.getMaxRowSize());
        System.out.println(md.getMaxSchemaNameLength());
        System.out.println(md.getMaxStatementLength());
        System.out.println(md.getMaxStatements());
        System.out.println(md.getMaxTableNameLength());
        System.out.println(md.getMaxUserNameLength());
        System.out.println(md.getNumericFunctions());
        System.out.println(md.getProcedureTerm());
        System.out.println(md.getResultSetHoldability());
        System.out.println(md.getSchemaTerm());
        System.out.println(md.getSearchStringEscape());
        System.out.println("Testing DatabaseMetaData.getSQLKeywords()");
        System.out.println(md.getSQLKeywords());
        System.out.println(md.getSQLStateType());
        System.out.println("Testing DatabaseMetaData.getStringFunctions()");
        System.out.println(md.getStringFunctions());
        System.out.println("Testing DatabaseMetaData.getSystemFunctions()");
        System.out.println(md.getSystemFunctions());
        System.out.println("Testing DatabaseMetaData.getTimeDateFunctions()");
        System.out.println(md.getTimeDateFunctions());
        System.out.println(md.getURL());
        System.out.println(md.getUserName());
        System.out.println(DatabaseMetaData.importedKeyCascade);
        System.out.println(md.isCatalogAtStart());
        System.out.println(md.isReadOnly());

        ResultSet rs;

        rs = md.getPrimaryKeys(null, null, "USER");

        ResultSetMetaData rsmd = rs.getMetaData();
        String result0 = "";

        for (; rs.next(); ) {
          for (int i = 0; i < rsmd.getColumnCount(); i++) {
            result0 += rs.getString(i + 1) + ":";
          }

          result0 += "\n";
        }

        rs.close();
        System.out.println(result0);
      }

      {
        ResultSet rs;

        rs = md.getBestRowIdentifier(null, null, "USER", 0, true);

        ResultSetMetaData rsmd = rs.getMetaData();
        String result0 = "";

        for (; rs.next(); ) {
          for (int i = 0; i < rsmd.getColumnCount(); i++) {
            result0 += rs.getString(i + 1) + ":";
          }

          result0 += "\n";
        }

        rs.close();
        System.out.println(result0);
      }

      {
        ResultSet rs = md.getImportedKeys(null, null, "ADDRESSBOOK");
        ResultSetMetaData rsmd = rs.getMetaData();

        result1 = "";

        for (; rs.next(); ) {
          for (int i = 0; i < rsmd.getColumnCount(); i++) {
            result1 += rs.getString(i + 1) + ":";
          }

          result1 += "\n";
        }

        rs.close();
        System.out.println(result1);
      }

      {
        ResultSet rs =
            md.getCrossReference(null, null, "ADDRESSBOOK_CATEGORY", null, null, "ADDRESSBOOK");
        ResultSetMetaData rsmd = rs.getMetaData();

        result2 = "";

        for (; rs.next(); ) {
          for (int i = 0; i < rsmd.getColumnCount(); i++) {
            result2 += rs.getString(i + 1) + ":";
          }

          result2 += "\n";
        }

        rs.close();
        System.out.println(result2);
      }

      {
        ResultSet rs = md.getExportedKeys(null, null, "USER");
        ResultSetMetaData rsmd = rs.getMetaData();

        result3 = "";

        for (; rs.next(); ) {
          for (int i = 0; i < rsmd.getColumnCount(); i++) {
            result3 += rs.getString(i + 1) + ":";
          }

          result3 += "\n";
        }

        rs.close();
        System.out.println(result3);
      }

      {
        ResultSet rs = md.getCrossReference(null, null, "USER", null, null, "ADDRESSBOOK_CATEGORY");
        ResultSetMetaData rsmd = rs.getMetaData();

        result4 = "";

        for (; rs.next(); ) {
          for (int i = 0; i < rsmd.getColumnCount(); i++) {
            result4 += rs.getString(i + 1) + ":";
          }

          result4 += "\n";
        }

        rs.close();
        System.out.println(result4);
      }

      {
        stmnt.execute("DROP TABLE T IF EXISTS;");
        stmnt.execute("CREATE TABLE T (I IDENTITY, A CHAR(20), B CHAR(20));");
        stmnt.execute("INSERT INTO T VALUES (NULL, 'get_column_name', '" + getColumnName + "');");

        ResultSet rs = stmnt.executeQuery("SELECT I, A, B, A \"aliasA\", B \"aliasB\", 1 FROM T;");
        ResultSetMetaData rsmd = rs.getMetaData();

        result5 = "";

        for (; rs.next(); ) {
          for (int i = 0; i < rsmd.getColumnCount(); i++) {
            result5 += rsmd.getColumnName(i + 1) + ":" + rs.getString(i + 1) + ":";
          }

          result5 += "\n";
        }

        rs.close();

        rs = stmnt.executeQuery("SELECT I, A, B, A \"aliasA\", B \"aliasB\", 1 FROM T;");
        rsmd = rs.getMetaData();

        for (; rs.next(); ) {
          for (int i = 0; i < rsmd.getColumnCount(); i++) {
            result5 += rsmd.getColumnLabel(i + 1) + ":" + rs.getString(i + 1) + ":";
          }

          result5 += "\n";
        }

        System.out.println(result5);
        System.out.println("first column identity: " + rsmd.isAutoIncrement(1));
        rsmd.isCaseSensitive(1);
        rsmd.isCurrency(1);
        rsmd.isDefinitelyWritable(1);
        rsmd.isNullable(1);
        rsmd.isReadOnly(1);
        rsmd.isSearchable(1);
        rsmd.isSigned(1);
        rsmd.isWritable(1);
        rs.close();

        // test identity with PreparedStatement
        pstmnt = connection.prepareStatement("INSERT INTO T VALUES (?,?,?)");

        pstmnt.setString(1, null);
        pstmnt.setString(2, "test");
        pstmnt.setString(3, "test2");
        pstmnt.executeUpdate();

        pstmnt = connection.prepareStatement("call identity()");

        ResultSet rsi = pstmnt.executeQuery();

        rsi.next();

        int identity = rsi.getInt(1);

        System.out.println("call identity(): " + identity);
        rsi.close();
      }
    } catch (SQLException e) {
      fail(e.getMessage());
    }

    System.out.println("testMetaData complete");

    // assert equality of exported and imported with xref
    assertEquals(result1, result2);
    assertEquals(result3, result4);
  }
 public String getDriverVersion() throws SQLException {
   return throwExceptionDelegate.getDriverVersion();
 }