You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafodion.apache.org by db...@apache.org on 2016/05/02 18:12:23 UTC
[44/60] incubator-trafodion git commit: Merge branch 'master' of
github.com:apache/incubator-trafodion into wrkbrnch
http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/a0f21cde/core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/T4DatabaseMetaData.java
----------------------------------------------------------------------
diff --cc core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/T4DatabaseMetaData.java
index d3b916d,0000000..d691a82
mode 100644,000000..100644
--- a/core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/T4DatabaseMetaData.java
+++ b/core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/T4DatabaseMetaData.java
@@@ -1,5901 -1,0 +1,5901 @@@
+// @@@ START COPYRIGHT @@@
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+//
+// @@@ END COPYRIGHT @@@
+
+package org.trafodion.jdbc.t4;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.RowIdLifetime;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+
+/**
+ * <p>
+ * JDBC Type 4 driver DataBaseMetaData class.
+ * </p>
+ * Comprehensive information about the database and Type 4 driver as
+ * a whole. This class lets applications users know the capabilities of database
+ * in combination with the Type 4 driver. Information returned
+ * by methods in this class applies to the capabilities of a Type 4 driver and
+ * Database working together. A user for this class is commonly a
+ * tool that needs to discover how to deal with the underlying
+ * Database. This is especially true for applications that are intended to be
+ * used with more than one DBMS. For example, a tool might use the method
+ * <code>getTypeInfo</code> to find out what data types can be used in a
+ * CREATE TABLE statement. Or a user might call the method
+ * <code>supportsCorrelatedSubqueries</code> to see if it is possible to use a
+ * correlated subquery or <code>supportsBatchUpdates</code> to see if it is
+ * possible to use batch updates. Some DatabaseMetaData methods return lists of
+ * information in the form of ResultSet objects. Regular ResultSet methods, such
+ * as getString and getInt, can be used to retrieve the data from these
+ * ResultSet objects. If a given form of metadata is not available, the
+ * ResultSet getter methods throw an SQLException. Some DatabaseMetaData methods
+ * take arguments that are String patterns. These arguments all have names such
+ * as fooPattern. Within a pattern String, "%" means match any substring of 0 or
+ * more characters, and "_" means match any one character. Only metadata entries
+ * matching the search pattern are returned. If a search pattern argument is set
+ * to null, that argument's criterion will be dropped from the search. A method
+ * that gets information about a feature that the Type 4 driver does not support
+ * will throw an SQLException. In the case of methods that return a ResultSet
+ * object, either a ResultSet object (which might be empty) is returned, or an
+ * SQLException is thrown.
+ *
+ * <p>
+ * Description: JDBC Type 4 Driver
+ * </p>
+ * <p>
+ * </p>
+ */
+public class T4DatabaseMetaData extends HPT4Handle implements java.sql.DatabaseMetaData {
+
+ // ----------------------------------------------------------------------
+ // First, a variety of minor information about the target database.
+
+ /*
+ * Can all the procedures returned by getProcedures be called by the current
+ * user?
+ *
+ * @return true if so
+ */
+ public boolean allProceduresAreCallable() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "allProceduresAreCallable", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("allProceduresAreCallable");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Can all the tables returned by getTable be SELECTed by the current user?
+ *
+ * @return true if so
+ */
+ public boolean allTablesAreSelectable() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "allTablesAreSelectable", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("allTablesAreSelectable");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * What's the url for this database?
+ *
+ * @return the url or null if it can't be generated * "TCP:<hostname>:<portnumber>/JDBC"
+ * is good enough.
+ */
+ public String getURL() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getURL", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getURL");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return connection_.getT4Properties().getUrl();
+ }
+
+ /*
+ * What's our user name as known to the database?
+ *
+ * @return our database user name *
+ *
+ */
+ public String getUserName() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getUserName", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getUserName");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return connection_.getServerHandle().getUid();
+ }
+
+ /*
+ * Is the database in read-only mode?
+ *
+ * @return true if so *
+ *
+ */
+ public boolean isReadOnly() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "isReadOnly", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("isReadOnly");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Are NULL values sorted high?
+ *
+ * @return true if so
+ *
+ */
+ public boolean nullsAreSortedHigh() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "nullsAreSortedHigh", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("nullsAreSortedHigh");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Are NULL values sorted low?
+ *
+ * @return true if so
+ */
+ public boolean nullsAreSortedLow() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "nullsAreSortedLow", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("nullsAreSortedLow");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Are NULL values sorted at the start regardless of sort order?
+ *
+ * @return true if so
+ */
+ public boolean nullsAreSortedAtStart() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "nullsAreSortedAtStart", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("nullsAreSortedAtStart");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Are NULL values sorted at the end regardless of sort order?
+ *
+ * @return true if so
+ */
+ public boolean nullsAreSortedAtEnd() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "nullsAreSortedAtEnd", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("nullsAreSortedAtEnd");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * What's the name of this database product?
+ *
+ * @return database product name
+ */
+ public String getDatabaseProductName() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getDatabaseProductName", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getDatabaseProductName");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("Trafodion");
+ }
+
+ /*
+ * What's the version of this database product?
+ *
+ * @return database version *
+ *
+ */
+ public String getDatabaseProductVersion() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getDatabaseProductVersion", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getDatabaseProductVersion");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("" + getDatabaseMajorVersion() + "." + getDatabaseMinorVersion());
+ }
+
+ /*
+ * What's the name of this JDBC driver?
+ *
+ * @return JDBC driver name
+ */
+ public String getDriverName() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getDriverName", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getDriverName");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("org.trafodion.jdbc.t4.T4Driver");
+ }
+
+ /*
+ * What's the version of this JDBC driver?
+ *
+ * @return JDBC driver version
+ */
+ public String getDriverVersion() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getDriverVersion", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getDriverVersion");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return Vproc.getVproc();
+ }
+
+ /*
+ * What's this JDBC driver's major version number?
+ *
+ * @return JDBC driver major version
+ */
+ public int getDriverMajorVersion() {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getDriverMajorVersion", "", p);
+ }
+ try {
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getDriverMajorVersion");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ } catch (SQLException se) {
+ // ignore
+ }
+ return Vproc.jdbcMajorVersion;
+ }
+
+ /*
+ * What's this JDBC driver's minor version number?
+ *
+ * @return JDBC driver minor version number
+ */
+ public int getDriverMinorVersion() {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getDriverMinorVersion", "", p);
+ }
+ try {
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getDriverMinorVersion");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ } catch (SQLException se) {
+ // ignore
+ }
+ return Vproc.jdbcMinorVersion;
+ }
+
+ /*
+ * Does the database store tables in a local file?
+ *
+ * @return true if so
+ */
+ public boolean usesLocalFiles() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "usesLocalFiles", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("usesLocalFiles");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Does the database use a file for each table?
+ *
+ * @return true if the database uses a local file for each table
+ */
+ public boolean usesLocalFilePerTable() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "usesLocalFilePerTable", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("usesLocalFilePerTable");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Database does not treat the mixed case unquoted SQL
+ * identifiers as case sensitive and does not store the result in mixed
+ * case.
+ *
+ * @return false always for the Type 4 driver.
+ */
+ public boolean supportsMixedCaseIdentifiers() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_
+ .logp(Level.FINE, "T4DatabaseMetaData", "supportsMixedCaseIdentifiers", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsMixedCaseIdentifiers");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Database treat mixed case unquoted SQL identifiers as case
+ * insensitive and store them in upper case.
+ * @return true always for the Type 4 driver.
+ */
+ public boolean storesUpperCaseIdentifiers() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "storesUpperCaseIdentifiers", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("storesUpperCaseIdentifiers");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Does the database treat mixed case unquoted SQL identifiers as case
+ * insensitive and store them in lower case?
+ *
+ * @return true if so
+ */
+ public boolean storesLowerCaseIdentifiers() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "storesLowerCaseIdentifiers", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("storesLowerCaseIdentifiers");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Does the database treat mixed case unquoted SQL identifiers as case
+ * insensitive and store them in mixed case?
+ *
+ * @return true if so
+ */
+ public boolean storesMixedCaseIdentifiers() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "storesMixedCaseIdentifiers", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("storesMixedCaseIdentifiers");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Database treat mixed case quoted SQL identifiers as case
+ * sensitive and as a result store them in mixed case.
+ * A JDBC-Compliant driver will always return false.
+ *
+ * @return true always true for the Type 4 drive.
+ */
+ public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsMixedCaseQuotedIdentifiers",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsMixedCaseQuotedIdentifiers");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Does the database treat mixed case quoted SQL identifiers as case
+ * insensitive and store them in upper case?
+ *
+ * @return true if so
+ */
+ public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "storesUpperCaseQuotedIdentifiers",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("storesUpperCaseQuotedIdentifiers");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Does the database treat mixed case quoted SQL identifiers as case
+ * insensitive and store them in lower case?
+ *
+ * @return true if so
+ */
+ public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "storesLowerCaseQuotedIdentifiers",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("storesLowerCaseQuotedIdentifiers");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Does the database treat mixed case quoted SQL identifiers as case
+ * insensitive and store them in mixed case?
+ *
+ * @return true if so
+ */
+ public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", " storesMixedCaseQuotedIdentifiers",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName(" storesMixedCaseQuotedIdentifiers");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Database uses the " string to quote SQL identifiers. This call
+ * returns a space " " if identifier quoting isn't supported.
+ * A JDBC-Compliant driver always uses a double quote character.
+ *
+ * @return the quoting string ".
+ */
+ public String getIdentifierQuoteString() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getIdentifierQuoteString", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getIdentifierQuoteString");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("\"");
+ }
+
+ /*
+ * Get a comma separated list of all a database's SQL keywords that are NOT
+ * also SQL92 keywords.
+ *
+ * @return the list *
+ *
+ */
+ public String getSQLKeywords() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getSQLKeywords", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getSQLKeywords");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return "DATETIME,FRACTION,PROTOTYPE,SQL_CHAR,SQL_DATE,SQL_DECIMAL,SQL_DOUBLE,SQL_FLOAT"
+ + ",SQL_INT,SQL_INTEGER,SQL_REAL,SQL_SMALLINT,SQL_TIME,SQL_TIMESTAMP,SQL_VARCHAR"
+ + ",TRANSPOSE,UPSHIFT";
+ }
+
+ /*
+ * Get a comma separated list of math functions.
+ *
+ * @return the list *
+ *
+ */
+ public String getNumericFunctions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getNumericFunctions", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getNumericFunctions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String(
+ "ABS,ACOS,ASIN,ATAN,ATAN2,CEILING,COS,COSH,DEGREES,EXP,FLOOR,LOG,LOG10,MOD,PI,POWER,RADIANS,RAND"
+ + "SIGN,SIN,SINH,SORT,TAN,TANH");
+ }
+
+ /*
+ * Get a comma separated list of string functions.
+ *
+ * @return the list *
+ *
+ */
+ public String getStringFunctions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getStringFunctions", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getStringFunctions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("ASCII,CHAR,CHAR_LENGTH,CONCAT,INSERT,LCASE,LEFT,LOCATE,LOWER,LPAD,LTRIM,OCTET_LENGTH"
+ + "POSITION,REPEAT,REPLACE,RIGHT,RPAD,RTRIM,SPACE,SUBSTRING,TRIM,UCASE,UPPER,UPSHIFT");
+ }
+
+ /*
+ * Get a comma separated list of system functions.
+ *
+ * @return the list *
+ *
+ */
+ public String getSystemFunctions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getSystemFunctions", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getSystemFunctions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("CURRENT_USER,USER");
+ }
+
+ /*
+ * Get a comma separated list of time and date functions.
+ *
+ * @return the list *
+ *
+ */
+ public String getTimeDateFunctions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getTimeDateFunctions", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getTimeDateFunctions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+
+ return new String("CONVERTTIMESTAMP,CURRENT,CURRENT_DATE,CURRENT_TIME,CURRENT_TIMESTAMP"
+ + "DATEFORMAT,DAY,DAYNAME,DAYOFMONTH,DAYOFWEEK,DAYOFYEAR,EXTRACT,HOUR,JULIANTIMESTAMP,MINUTE"
+ + "MONTH,MONTHNAME,QUARTER,SECOND,WEEK,YEAR");
+ }
+
+ /*
+ * This is the string that can be used to escape '_' or '%' in the string
+ * pattern style catalog search parameters.
+ *
+ * <P>The '_' character represents any single character. <P>The '%'
+ * character represents any sequence of zero or more characters. @return the
+ * string used to escape wildcard characters *
+ *
+ */
+ public String getSearchStringEscape() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getSearchStringEscape", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getSearchStringEscape");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("\\");
+ }
+
+ /*
+ * Get all the "extra" characters that can be used in unquoted identifier
+ * names (those beyond a-z, A-Z, 0-9 and _).
+ *
+ * @return the string containing the extra characters
+ */
+ public String getExtraNameCharacters() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getExtraNameCharacters", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getExtraNameCharacters");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return null;
+ }
+
+ // --------------------------------------------------------------------
+ // Functions describing which features are supported.
+
+ /*
+ * Is "ALTER TABLE" with add column supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsAlterTableWithAddColumn() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsAlterTableWithAddColumn",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsAlterTableWithAddColumn");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Is "ALTER TABLE" with drop column supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsAlterTableWithDropColumn() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsAlterTableWithDropColumn",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsAlterTableWithDropColumn");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Is column aliasing supported?
+ *
+ * <P>If so, the SQL AS clause can be used to provide names for computed
+ * columns or to provide alias names for columns as required.
+ *
+ * A JDBC-Compliant driver always returns true.
+ *
+ * @return true if so
+ */
+ public boolean supportsColumnAliasing() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsColumnAliasing", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsColumnAliasing");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Database concatenations between NULL and non-NULL values is
+ * NULL.
+ *
+ * A JDBC-Compliant driver always returns true.
+ *
+ * @return true always for the Type 4 driver.
+ */
+ public boolean nullPlusNonNullIsNull() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "nullPlusNonNullIsNull", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("nullPlusNonNullIsNull");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Is the CONVERT function between SQL types supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsConvert() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsConvert", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsConvert");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Is CONVERT between the given SQL types supported?
+ *
+ * @param fromType the type to convert from @param toType the type to
+ * convert to @return true if so
+ *
+ * @see Types
+ */
+ public boolean supportsConvert(int fromType, int toType) throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_, fromType, toType);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsConvert", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_, fromType, toType);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsConvert");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ switch (fromType) {
+ case Types.BIGINT:
+ case Types.DECIMAL:
+ case Types.DOUBLE:
+ case Types.FLOAT:
+ case Types.INTEGER:
+ case Types.NUMERIC:
+ case Types.REAL:
+ case Types.SMALLINT:
+ switch (toType) {
+ case Types.CHAR:
+ case Types.NUMERIC:
+ case Types.DECIMAL:
+ case Types.INTEGER:
+ case Types.SMALLINT:
+ case Types.FLOAT:
+ case Types.REAL:
+ case Types.DOUBLE:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ case Types.BIGINT:
+ return true;
+ default:
+ return false;
+ }
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ switch (toType) {
+ case Types.CHAR:
+ case Types.NUMERIC:
+ case Types.DECIMAL:
+ case Types.INTEGER:
+ case Types.SMALLINT:
+ case Types.FLOAT:
+ case Types.REAL:
+ case Types.DOUBLE:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ case Types.BIGINT:
+ case Types.DATE:
+ case Types.TIME:
+ case Types.TIMESTAMP:
+ return true;
+ default:
+ return false;
+ }
+ case Types.DATE:
+ switch (toType) {
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ case Types.DATE:
+ case Types.TIMESTAMP:
+ return true;
+ default:
+ return false;
+ }
+ case Types.TIME:
+ switch (toType) {
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ case Types.TIME:
+ case Types.TIMESTAMP:
+ return true;
+ default:
+ return false;
+ }
+ case Types.TIMESTAMP:
+ switch (toType) {
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ case Types.DATE:
+ case Types.TIME:
+ case Types.TIMESTAMP:
+ return true;
+ default:
+ return false;
+ }
+ case Types.BIT:
+ case Types.BINARY:
+ case Types.VARBINARY:
+ case Types.LONGVARBINARY:
+ case Types.TINYINT:
+ return false;
+ default:
+ return false;
+ }
+ }
+
+ /*
+ * Type 4 driver supports table correlation names. Type 4 driver always
+ * returns true.
+ *
+ * @return true for Type 4 driver
+ */
+ public boolean supportsTableCorrelationNames() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsTableCorrelationNames", "",
+ p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsTableCorrelationNames");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Database table correlation names are supported, and they are
+ * not restricted to be different from the names of the Database
+ * tables.
+ *
+ * @return false always for Type 4 driver.
+ */
+ public boolean supportsDifferentTableCorrelationNames() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData",
+ "supportsDifferentTableCorrelationNames", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsDifferentTableCorrelationNames");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * SQL expressions in "ORDER BY" lists are not supported by the
+ * Database and Type 4 driver.
+ *
+ * @return false always for Type 4 driver.
+ */
+ public boolean supportsExpressionsInOrderBy() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_
+ .logp(Level.FINE, "T4DatabaseMetaData", "supportsExpressionsInOrderBy", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsExpressionsInOrderBy");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Can an "ORDER BY" clause use columns not in the SELECT?
+ *
+ * @return true if so
+ */
+ public boolean supportsOrderByUnrelated() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsOrderByUnrelated", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsOrderByUnrelated");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Is some form of "GROUP BY" clause supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsGroupBy() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsGroupBy", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsGroupBy");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a "GROUP BY" clause use columns not in the SELECT?
+ *
+ * @return true if so
+ */
+ public boolean supportsGroupByUnrelated() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsGroupByUnrelated", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsGroupByUnrelated");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Can a "GROUP BY" clause add columns not in the SELECT provided it
+ * specifies all the columns in the SELECT?
+ *
+ * @return true if so
+ */
+ public boolean supportsGroupByBeyondSelect() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsGroupByBeyondSelect", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsGroupByBeyondSelect");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Database supports escape character in "LIKE" clauses.
+ * A JDBC-Compliant driver always returns true.
+ *
+ * @return true always true for the Type 4 driver.
+ */
+ public boolean supportsLikeEscapeClause() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsLikeEscapeClause", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsLikeEscapeClause");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Are multiple ResultSets from a single execute supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsMultipleResultSets() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsMultipleResultSets", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsMultipleResultSets");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can we have multiple transactions open at once (on different
+ * connections)?
+ *
+ * @return true if so
+ */
+ public boolean supportsMultipleTransactions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_
+ .logp(Level.FINE, "T4DatabaseMetaData", "supportsMultipleTransactions", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsMultipleTransactions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ // Need to change it 'true' once Database fixes this problem
+ return false;
+ }
+
+ /*
+ * Database table columns can be defined as non-nullable.
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsNonNullableColumns() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsNonNullableColumns", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsNonNullableColumns");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Type 4 driver supports the ODBC Minimum SQL grammar.
+ *
+ * All JDBC-Compliant drivers must return true.
+ *
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsMinimumSQLGrammar() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsMinimumSQLGrammar", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsMinimumSQLGrammar");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Is the ODBC Core SQL grammar supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsCoreSQLGrammar() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsCoreSQLGrammar", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsCoreSQLGrammar");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Is the ODBC Extended SQL grammar supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsExtendedSQLGrammar() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsExtendedSQLGrammar", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsExtendedSQLGrammar");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Database supports the ANSI92 entry level SQL grammar.
+ * All JDBC-Compliant drivers must return true.
+ *
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsANSI92EntryLevelSQL() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsANSI92EntryLevelSQL", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsANSI92EntryLevelSQL");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Is the ANSI92 intermediate SQL grammar supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsANSI92IntermediateSQL() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsANSI92IntermediateSQL", "",
+ p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsANSI92IntermediateSQL");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Is the ANSI92 full SQL grammar supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsANSI92FullSQL() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsANSI92FullSQL", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsANSI92FullSQL");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Is the SQL Integrity Enhancement Facility supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsIntegrityEnhancementFacility() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData",
+ "supportsIntegrityEnhancementFacility", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsIntegrityEnhancementFacility");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Is some form of outer join supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsOuterJoins() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsOuterJoins", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsOuterJoins");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Are full nested outer joins supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsFullOuterJoins() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsFullOuterJoins", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsFullOuterJoins");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Database provides the limited support for outer joins. This
+ * will be true if supportFullOuterJoins is true.
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsLimitedOuterJoins() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsLimitedOuterJoins", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsLimitedOuterJoins");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * What's the database vendor's preferred term for "schema"?
+ *
+ * @return the vendor term
+ */
+ public String getSchemaTerm() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getSchemaTerm", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getSchemaTerm");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("SCHEMA");
+ }
+
+ /*
+ * What's the database vendor's preferred term for "procedure"?
+ *
+ * @return the vendor term
+ */
+ public String getProcedureTerm() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getProcedureTerm", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getProcedureTerm");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("PROCEDURE");
+ }
+
+ /*
+ * What's the database vendor's preferred term for "catalog"?
+ *
+ * @return the vendor term
+ */
+ public String getCatalogTerm() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getCatalogTerm", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getCatalogTerm");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String("CATALOG");
+ }
+
+ /*
+ * Database catalog name appear at the start of a qualified table
+ * name. (Otherwise it appears at the end)
+ * @return true always for the Type 4 driver.
+ */
+ public boolean isCatalogAtStart() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "isCatalogAtStart", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("isCatalogAtStart");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * What's the separator between catalog and table name?
+ *
+ * @return the separator string
+ */
+ public String getCatalogSeparator() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "getCatalogSeparator", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("getCatalogSeparator");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return new String(".");
+ }
+
+ /*
+ * Can a schema name be used in a data manipulation statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsSchemasInDataManipulation() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsSchemasInDataManipulation",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSchemasInDataManipulation");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a schema name be used in a procedure call statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsSchemasInProcedureCalls() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsSchemasInProcedureCalls",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSchemasInProcedureCalls");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a schema name be used in a table definition statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsSchemasInTableDefinitions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsSchemasInTableDefinitions",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSchemasInTableDefinitions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a schema name be used in an index definition statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsSchemasInIndexDefinitions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsSchemasInIndexDefinitions",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSchemasInIndexDefinitions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a schema name be used in a privilege definition statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData",
+ "supportsSchemasInPrivilegeDefinitions", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSchemasInPrivilegeDefinitions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a catalog name be used in a data manipulation statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsCatalogsInDataManipulation() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsCatalogsInDataManipulation",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsCatalogsInDataManipulation");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a catalog name be used in a procedure call statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsCatalogsInProcedureCalls() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsCatalogsInProcedureCalls",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsCatalogsInProcedureCalls");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a catalog name be used in a table definition statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsCatalogsInTableDefinitions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsCatalogsInTableDefinitions",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsCatalogsInTableDefinitions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a catalog name be used in an index definition statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsCatalogsInIndexDefinitions",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsCatalogsInIndexDefinitions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can a catalog name be used in a privilege definition statement?
+ *
+ * @return true if so
+ */
+ public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData",
+ "supportsCatalogsInPrivilegeDefinitions", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsCatalogsInPrivilegeDefinitions");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Is positioned DELETE supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsPositionedDelete() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsPositionedDelete", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsPositionedDelete");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Database supports positioned UPDATE supported through the Type
+ * 4 driver.
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsPositionedUpdate() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsPositionedUpdate", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsPositionedUpdate");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Database supports SELECT for UPDATE through the Type 4 driver.
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsSelectForUpdate() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsSelectForUpdate", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSelectForUpdate");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * stored procedure calls using the stored procedure escape syntax
+ * are supported.
+ *
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsStoredProcedures() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsStoredProcedures", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsStoredProcedures");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Trafodion Database Database subqueries in comparison expressions are supported
+ * through the Type 4 driver.
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsSubqueriesInComparisons() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsSubqueriesInComparisons",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSubqueriesInComparisons");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Trafodion Database supports subqueries in 'exists' expressions through
+ * Type 4 driver.
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsSubqueriesInExists() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsSubqueriesInExists", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSubqueriesInExists");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Trafodion Database supports subqueries in 'in' statements through the
+ * Type 4 driver.
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsSubqueriesInIns() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsSubqueriesInIns", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSubqueriesInIns");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * The subqueries in quantified expressions supported in Trafodion Database
+ * and Type 4 driver.
+ * @return true always for Type 4 driver.
+ */
+ public boolean supportsSubqueriesInQuantifieds() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsSubqueriesInQuantifieds",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsSubqueriesInQuantifieds");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Trafodion Database supports correlated subqueries.
+ * A JDBC-Compliant driver always returns true.
+ *
+ * @return true always for the Type 4 driver.
+ */
+ public boolean supportsCorrelatedSubqueries() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_
+ .logp(Level.FINE, "T4DatabaseMetaData", "supportsCorrelatedSubqueries", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsCorrelatedSubqueries");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Is SQL UNION supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsUnion() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsUnion", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsUnion");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Is SQL UNION ALL supported?
+ *
+ * @return true if so
+ */
+ public boolean supportsUnionAll() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsUnionAll", "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsUnionAll");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return true;
+ }
+
+ /*
+ * Can cursors remain open across commits?
+ *
+ * @return true if cursors always remain open; false if they might not
+ * remain open
+ */
+ public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsOpenCursorsAcrossCommit",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ lr.setParameters(p);
+ lr.setSourceClassName("T4DatabaseMetaData");
+ lr.setSourceMethodName("supportsOpenCursorsAcrossCommit");
+ T4LogFormatter lf = new T4LogFormatter();
+ String temp = lf.format(lr);
+ connection_.props_.getLogWriter().println(temp);
+ }
+ return false;
+ }
+
+ /*
+ * Can cursors remain open across rollbacks?
+ *
+ * @return true if cursors always remain open; false if they might not
+ * remain open
+ */
+ public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
+ if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+ connection_.props_.t4Logger_.logp(Level.FINE, "T4DatabaseMetaData", "supportsOpenCursorsAcrossRollback",
+ "", p);
+ }
+ if (connection_.props_.getLogWriter() != null) {
+ LogRecord lr = new LogRecord(Level.FINE, "");
+ Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+
<TRUNCATED>