picodatabasemetadata.java

picoSQL is a SQL-based, multi-user, client/server RDBMS, released under the GPL

/*
_____       _    _    Corso   Italia,  178
(_|__   .  (_   |_|_  56125           Pisa
(_|_) |)|(()_)()| |   tel.  [phone]
  |   |               [e-mail]

 Copyright (C) Picosoft s.r.l. 1995-2002

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/
package IT.picosoft.jdbc;

import java.sql.*;

public class PicoDatabaseMetaData implements DatabaseMetaData {

   protected PicoDbApi odbcApi;
   protected PicoConnection con;

   public PicoDatabaseMetaData(PicoDbApi api, PicoConnection conn) {
      odbcApi = api;
      con = conn;
   }

   protected String getInfoString(short opt) throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("getInfoString opt=" + opt);
      validateConnection();
      switch (opt) {
         case OdbcDef.SQL_ACCESSIBLE_TABLES:
            return "Y";
         case OdbcDef.SQL_ACCESSIBLE_PROCEDURES:
            return "N";
         case OdbcDef.SQL_TXN_CAPABLE:
            return String.valueOf(OdbcDef.SQL_TC_DDL_IGNORE);
         case OdbcDef.SQL_MAX_ROW_SIZE_INCLUDES_LONG:
            return "Y";
         case OdbcDef.SQL_QUALIFIER_NAME_SEPARATOR:
            return "";
         case OdbcDef.SQL_QUALIFIER_TERM:
            return "";
         case OdbcDef.SQL_DBMS_NAME:
            return "picoSQL";
         case OdbcDef.SQL_DBMS_VER:
            return "4.00.0000";
         case OdbcDef.SQL_DRIVER_VER:
            return "4.00.0000";
         case OdbcDef.SQL_DEFAULT_TXN_ISOLATION:
            return String.valueOf(OdbcDef.SQL_TXN_READ_UNCOMMITTED);
         case OdbcDef.SQL_SPECIAL_CHARACTERS:
            return "";
         case OdbcDef.SQL_IDENTIFIER_QUOTE_CHAR:
            return " ";
         case OdbcDef.SQL_MAX_BINARY_LITERAL_LEN:
            return "0";
         case OdbcDef.SQL_MAX_QUALIFIER_NAME_LEN:
            return "0";
         case OdbcDef.SQL_MAX_CHAR_LITERAL_LEN:
            return "32767";
         case OdbcDef.SQL_MAX_COLUMN_NAME_LEN:
            return "30";
         case OdbcDef.SQL_MAX_COLUMNS_IN_GROUP_BY:
            return "0";
         case OdbcDef.SQL_MAX_COLUMNS_IN_INDEX:
            return "0";
         case OdbcDef.SQL_MAX_COLUMNS_IN_ORDER_BY:
            return "0";
         case OdbcDef.SQL_MAX_COLUMNS_IN_SELECT:
            return "0";
         case OdbcDef.SQL_MAX_COLUMNS_IN_TABLE:
            return "0";
         case OdbcDef.SQL_ACTIVE_CONNECTIONS:
            return "0";
         case OdbcDef.SQL_MAX_CURSOR_NAME_LEN:
            return "0";
         case OdbcDef.SQL_MAX_INDEX_SIZE:
            return "250";
         case OdbcDef.SQL_MAX_PROCEDURE_NAME_LEN:
            return "0";
         case OdbcDef.SQL_MAX_ROW_SIZE:
            return "32767";
         case OdbcDef.SQL_MAX_OWNER_NAME_LEN:
            return "0";
         case OdbcDef.SQL_MAX_STATEMENT_LEN:
            return "0";
         case OdbcDef.SQL_ACTIVE_STATEMENTS:
            return "0";
         case OdbcDef.SQL_MAX_TABLE_NAME_LEN:
            return "30";
         case OdbcDef.SQL_MAX_TABLES_IN_SELECT:
            return "0";
         case OdbcDef.SQL_MAX_USER_NAME_LEN:
            return "30";
         case OdbcDef.SQL_NUMERIC_FUNCTIONS:
            return String.valueOf (OdbcDef.SQL_FN_NUM_ABS|
                                   OdbcDef.SQL_FN_NUM_ROUND);
         case OdbcDef.SQL_PROCEDURE_TERM:
            return "";
         case OdbcDef.SQL_KEYWORDS:
            return "";
         case OdbcDef.SQL_OWNER_TERM:
            return "";
         case OdbcDef.SQL_SEARCH_PATTERN_ESCAPE:
            return "\\";
         case OdbcDef.SQL_STRING_FUNCTIONS:
            return String.valueOf (OdbcDef.SQL_FN_STR_CONCAT|
                                   OdbcDef.SQL_FN_STR_LTRIM|
                                   OdbcDef.SQL_FN_STR_LENGTH|
                                   OdbcDef.SQL_FN_STR_LCASE |
                                   OdbcDef.SQL_FN_STR_RTRIM |
                                   OdbcDef.SQL_FN_STR_SUBSTRING |
                                   OdbcDef.SQL_FN_STR_UCASE);
         case OdbcDef.SQL_SYSTEM_FUNCTIONS:
            return "0";
         case OdbcDef.SQL_TIMEDATE_FUNCTIONS:
            return "0";
         case OdbcDef.SQL_USER_NAME:
            return "";
         case OdbcDef.SQL_QUALIFIER_LOCATION:
            return "0";
         case OdbcDef.SQL_DATA_SOURCE_READ_ONLY:
            return "N";
         case OdbcDef.SQL_CONCAT_NULL_BEHAVIOR:
            return String.valueOf(OdbcDef.SQL_CB_NON_NULL);
         case OdbcDef.SQL_NULL_COLLATION:
            return String.valueOf (OdbcDef.SQL_NC_START);
         case OdbcDef.SQL_IDENTIFIER_CASE:
            return String.valueOf (OdbcDef.SQL_IC_UPPER);
         case OdbcDef.SQL_QUOTED_IDENTIFIER_CASE:
            return String.valueOf (OdbcDef.SQL_IC_UPPER);
         case OdbcDef.SQL_ALTER_TABLE:
            return "0";
         case OdbcDef.SQL_QUALIFIER_USAGE:
            return "0";
         case OdbcDef.SQL_COLUMN_ALIAS:
            return "Y";
         case OdbcDef.SQL_CONVERT_FUNCTIONS:
            return String.valueOf (OdbcDef.SQL_FN_CVT_CONVERT);
         case OdbcDef.SQL_ODBC_SQL_CONFORMANCE:
            return String.valueOf (OdbcDef.SQL_OSC_CORE);
         case OdbcDef.SQL_SUBQUERIES:
            return String.valueOf (OdbcDef.SQL_SQ_EXISTS);
         case OdbcDef.SQL_EXPRESSIONS_IN_ORDERBY:
            return "N";
         case OdbcDef.SQL_OUTER_JOINS:
            return "Y";
         case OdbcDef.SQL_GROUP_BY:
            return String.valueOf(
                          OdbcDef.SQL_GB_GROUP_BY_CONTAINS_SELECT);
         case OdbcDef.SQL_ODBC_SQL_OPT_IEF:
            return "N";
         case OdbcDef.SQL_LIKE_ESCAPE_CLAUSE:
            return "N";
         case OdbcDef.SQL_MULT_RESULT_SETS:
            return "N";
         case OdbcDef.SQL_MULTIPLE_ACTIVE_TXN:
            return "N";
         case OdbcDef.SQL_NON_NULLABLE_COLUMNS:
            return "0";
         case OdbcDef.SQL_CURSOR_COMMIT_BEHAVIOR:
         case OdbcDef.SQL_CURSOR_ROLLBACK_BEHAVIOR:
            return String.valueOf(OdbcDef.SQL_CB_PRESERVE);
         case OdbcDef.SQL_POSITIONED_STATEMENTS:
            return "0";
         case OdbcDef.SQL_OWNER_USAGE:
            return "0";
         case OdbcDef.SQL_PROCEDURES:
            return "N";
         case OdbcDef.SQL_CORRELATION_NAME:
            return String.valueOf(OdbcDef.SQL_CN_ANY);
         case OdbcDef.SQL_UNION:
            return "0";
         case OdbcDef.SQL_FILE_USAGE:
            return String.valueOf(OdbcDef.SQL_FILE_NOT_SUPPORTED);
      }
      throw new UnsupportedOperationException();
   }
   protected int getInfo(short opt) throws SQLException {
      return Integer.parseInt (getInfoString(opt));
   }
   protected short getInfoShort(short opt) throws SQLException {
      return Short.parseShort (getInfoString(opt));
   }

   protected void validateConnection() throws SQLException {
      con.validateConnection();
   }

   protected boolean getInfoBooleanString(short opt) throws SQLException {
      validateConnection();
      String s = "N";
      return s.equalsIgnoreCase("Y");
   }

   public boolean allProceduresAreCallable() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.allProceduresAreCallable");
      return getInfoBooleanString(OdbcDef.SQL_ACCESSIBLE_PROCEDURES);
   }

   public boolean allTablesAreSelectable() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.allTablesAreSelectable");
      return getInfoBooleanString(OdbcDef.SQL_ACCESSIBLE_TABLES);
   }

   public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.dataDefintionCausesTransactionCommit");
      int i = getInfoShort(OdbcDef.SQL_TXN_CAPABLE);
      return (i & 0x3) > 0;
   }
   public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.dataDefintionIgnoredInTransactions");
      int i = getInfoShort(OdbcDef.SQL_TXN_CAPABLE);
      return (i & 0x4) > 0;
   }

   public boolean deletesAreDetected(int i) {
      throw new UnsupportedOperationException();
   }

   public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.doesMaxRowSizeIncludeBlobs");
      return getInfoBooleanString(OdbcDef.SQL_MAX_ROW_SIZE_INCLUDES_LONG);
   }

   public ResultSet getBestRowIdentifier(String s, String s1,
                       String s2, int i, boolean flag) throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getBestRowIdentifier (" + s + "," + s1 + "," + s2 + "," + i + "," + flag + ")");
      
      PicoResultSet rs = null;
      SQLWarning sqlwarning = null;
      OdbcStatement hstmt = new OdbcStatement (odbcApi, con.getHDBC());
      try {
         odbcApi.SQLSpecialColumns(hstmt, (short)1, s, s1, s2, i, flag);
      } catch(SQLWarning sqlwarning1) {
         sqlwarning = sqlwarning1;
      }
      catch(SQLException sqlexception) {
         hstmt.drop();
         throw sqlexception;
      }
      rs = new PicoResultSet(odbcApi, hstmt, con);
      rs.setWarning(sqlwarning);
      rs.setSQLTypeColumn(3);
      return rs;
   }

   public String getCatalogSeparator() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getCatalogSeparator");
      return getInfoString(OdbcDef.SQL_QUALIFIER_NAME_SEPARATOR);
   }

   public String getCatalogTerm() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getCatalogTerm");
      return getInfoString(OdbcDef.SQL_QUALIFIER_TERM);
   }

   public ResultSet getCatalogs() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getCatalogs");
      PicoResultSet rs = (PicoResultSet)getTables("%", "", "", null);
      int ai[] = new int[1];
      ai[0] = 1;
      rs.setColumnMappings(ai);
      return rs;
   }

   public ResultSet getColumnPrivileges(String s, String s1, String s2,
                                        String s3) throws SQLException {
      throw new UnsupportedOperationException();
   }

   public ResultSet getColumns(String s, String s1, String s2, String s3)
      throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getColumns (" + s + "," + s1 + "," + s2 + "," + s3 + ")");
      PicoResultSet rs = null;
      SQLWarning sqlwarning = null;
      OdbcStatement hstmt = new OdbcStatement (odbcApi, con.getHDBC());
      try {
         odbcApi.SQLColumns(hstmt, s, s1, s2, s3);
      } catch(SQLWarning sqlwarning1) {
         sqlwarning = sqlwarning1;
      }
      catch(SQLException sqlexception) {
         hstmt.drop();
         throw sqlexception;
      }
      rs = new PicoResultSet(odbcApi, hstmt, con);
      rs.setWarning(sqlwarning);
      PicoPseudoCol pcol[] = new PicoPseudoCol[10];
      pcol[0] = new PicoPseudoCol("COLUMN_DEF", OdbcDef.SQL_VARCHAR, 254);
      pcol[1] = new PicoPseudoCol("SQL_DATA_TYPE", OdbcDef.SQL_INTEGER, 0);
      pcol[2] = new PicoPseudoCol("SQL_DATETIME_SUB", OdbcDef.SQL_INTEGER, 0);
      pcol[3] = new PicoPseudoCol("CHAR_OCTET_LENGTH", OdbcDef.SQL_INTEGER, 0);
      pcol[4] = new PicoPseudoCol("ORDINAL_POSITION", OdbcDef.SQL_INTEGER, 0);
      pcol[5] = new PicoPseudoCol("IS_NULLABLE", OdbcDef.SQL_VARCHAR, 254);
      pcol[6] = new PicoPseudoCol("SCOPE_CATLOG", OdbcDef.SQL_VARCHAR, 254);
      pcol[7] = new PicoPseudoCol("SCOPE_SCHEMA", OdbcDef.SQL_VARCHAR, 254);
      pcol[8] = new PicoPseudoCol("SCOPE_TABLE", OdbcDef.SQL_VARCHAR, 254);
      pcol[9] = new PicoPseudoCol("SOURCE_DATA_TYPE", OdbcDef.SQL_SMALLINT, 0);
      rs.setPseudoCols(13, 22, pcol);
      rs.setSQLTypeColumn(5);
      return rs;
   }

   public Connection getConnection() {
      return con;
   }

   public ResultSet getCrossReference(String s, String s1, String s2,
                                      String s3, String s4, String s5)
      throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getCrossReference (" + s + "," + s1 + "," + s2 + "," + s3 + "," + s4 + "," + s5 + ")");
      throw new UnsupportedOperationException();
   }

   public String getDatabaseProductName() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getDatabaseProductName");
      return getInfoString(OdbcDef.SQL_DBMS_NAME);
   }

   public String getDatabaseProductVersion() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getDatabaseProductVersion");
      return getInfoString(OdbcDef.SQL_DBMS_VER);
   }

   public int getDefaultTransactionIsolation() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getDefaultTransactionIsolation");
      return (byte) getInfo(OdbcDef.SQL_DEFAULT_TXN_ISOLATION);
   }

   public int getDriverMajorVersion() {
      return 4;
   }

   public int getDriverMinorVersion() {
      return 0001;
   }

   public String getDriverName() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getDriverName");
      return "picoSQL JDBC driver";
   }

   public String getDriverVersion() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getDriverVersion");
      int i = getDriverMinorVersion();
      String s = "";
      if(i < 1000)
         s = s + "0";
      if(i < 100)
         s = s + "0";
      if(i < 10)
         s = s + "0";
      s = s + "" + i;
      return getDriverMajorVersion() + "." + s + " (" + getInfoString(OdbcDef.SQL_DRIVER_VER) + ")";
   }

   public ResultSet getExportedKeys(String s, String s1, String s2)
      throws SQLException {
      throw new UnsupportedOperationException();
   }

   public String getExtraNameCharacters() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getExtraNameCharacters");
      return getInfoString(OdbcDef.SQL_SPECIAL_CHARACTERS);
   }

   public String getIdentifierQuoteString() throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getIdentifierQuoteString");
      return getInfoString(OdbcDef.SQL_IDENTIFIER_QUOTE_CHAR);
   }

   public ResultSet getImportedKeys(String s, String s1, String s2)
      throws SQLException {
      throw new UnsupportedOperationException();
   }

   public ResultSet getIndexInfo(String s, String s1, String s2,
                            boolean flag, boolean flag1) throws SQLException {
      if(DriverManager.getLogWriter() != null)
         DriverManager.println("*DatabaseMetaData.getIndexInfo (" + s + "," + s1 + "," + s2 + flag + "," + flag1 + ")");
      PicoResultSet rs = null;
      SQLWarning sqlwarning = null;
      OdbcStatement hstmt = new OdbcStatement (odbcApi, con.getHDBC());
      try {
         odbcApi.SQLStatistics(hstmt, s, s1, s2, flag, flag1);
      } catch(SQLWarning sqlwarning1) {
         sqlwarning = sqlwarning1;