/**
 * 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.
 */
package org.apache.drill.jdbc.impl;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.RowIdLifetime;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ExecutionException;

import org.apache.calcite.avatica.AvaticaDatabaseMetaData;
import org.apache.drill.common.Version;
import org.apache.drill.common.exceptions.DrillRuntimeException;
import org.apache.drill.common.types.TypeProtos.MinorType;
import org.apache.drill.common.types.Types;
import org.apache.drill.exec.client.ServerMethod;
import org.apache.drill.exec.proto.UserBitShared.DrillPBError;
import org.apache.drill.exec.proto.UserProtos.ConvertSupport;
import org.apache.drill.exec.proto.UserProtos.CorrelationNamesSupport;
import org.apache.drill.exec.proto.UserProtos.GetServerMetaResp;
import org.apache.drill.exec.proto.UserProtos.GroupBySupport;
import org.apache.drill.exec.proto.UserProtos.IdentifierCasing;
import org.apache.drill.exec.proto.UserProtos.NullCollation;
import org.apache.drill.exec.proto.UserProtos.OrderBySupport;
import org.apache.drill.exec.proto.UserProtos.OuterJoinSupport;
import org.apache.drill.exec.proto.UserProtos.RequestStatus;
import org.apache.drill.exec.proto.UserProtos.ServerMeta;
import org.apache.drill.exec.proto.UserProtos.SubQuerySupport;
import org.apache.drill.exec.proto.UserProtos.UnionSupport;
import org.apache.drill.jdbc.AlreadyClosedSqlException;
import org.apache.drill.jdbc.DrillDatabaseMetaData;

import com.google.common.base.Joiner;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableSet;


/**
 * Drill's implementation of {@link DatabaseMetaData}.
 */
class DrillDatabaseMetaDataImpl extends AvaticaDatabaseMetaData
                                implements DrillDatabaseMetaData {


  /**
   * Holds allowed conversion between SQL types
   *
   */
  private static final class SQLConvertSupport {
    public final int from;
    public final int to;

    public SQLConvertSupport(int from, int to) {
      this.from = from;
      this.to = to;
    }

    @Override
    public int hashCode() {
      return Objects.hash(from, to);
    }

    @Override public boolean equals(Object obj) {
      if (this == obj) {
        return true;
      }

      if (!(obj instanceof SQLConvertSupport)) {
        return false;
      }

      SQLConvertSupport other = (SQLConvertSupport) obj;
      return from == other.from && to == other.to;
    }

    public static final Set<SQLConvertSupport> toSQLConvertSupport(Iterable<ConvertSupport> convertSupportIterable) {
      ImmutableSet.Builder<SQLConvertSupport> sqlConvertSupportSet = ImmutableSet.builder();
      for(ConvertSupport convertSupport: convertSupportIterable) {
        try {
          sqlConvertSupportSet.add(new SQLConvertSupport(
              toSQLType(convertSupport.getFrom()),
              toSQLType(convertSupport.getTo())));
        } catch(IllegalArgumentException e) {
          // Ignore unknown types...
        }
      }
      return sqlConvertSupportSet.build();
    }

    private static int toSQLType(MinorType minorType) {
      String sqlTypeName = Types.getSqlTypeName(Types.optional(minorType));
      return Types.getJdbcTypeCode(sqlTypeName);
    }
  }

  private volatile ServerMeta serverMeta;
  private volatile Set<SQLConvertSupport> convertSupport;

  protected DrillDatabaseMetaDataImpl( DrillConnectionImpl connection ) {
    super( connection );

  }

  /**
   * Throws AlreadyClosedSqlException if the associated Connection is closed.
   *
   * @throws AlreadyClosedSqlException if Connection is closed
   * @throws SQLException if error in calling {@link Connection#isClosed()}
   */
  private void throwIfClosed() throws AlreadyClosedSqlException,
                                      SQLException {
    if ( getConnection().isClosed() ) {
      throw new AlreadyClosedSqlException(
          "DatabaseMetaData's Connection is already closed." );
    }
  }

  private boolean getServerMetaSupported() throws SQLException {
    DrillConnectionImpl connection = (DrillConnectionImpl) getConnection();
    return
        !connection.getConfig().isServerMetadataDisabled()
        && connection.getClient().getSupportedMethods().contains(ServerMethod.GET_SERVER_META);
  }

  private String getServerName() throws SQLException {
    DrillConnectionImpl connection = (DrillConnectionImpl) getConnection();
    return connection.getClient().getServerName();
  }

  private Version getServerVersion() throws SQLException {
    DrillConnectionImpl connection = (DrillConnectionImpl) getConnection();
    return connection.getClient().getServerVersion();
  }

  private ServerMeta getServerMeta() throws SQLException {
    assert getServerMetaSupported();

    if (serverMeta == null) {
      synchronized(this) {
        if (serverMeta == null) {
          DrillConnectionImpl connection = (DrillConnectionImpl) getConnection();

          try {
            GetServerMetaResp resp = connection.getClient().getServerMeta().get();
            if (resp.getStatus() != RequestStatus.OK) {
              DrillPBError drillError = resp.getError();
              throw new SQLException("Error when getting server meta: " + drillError.getMessage());
            }
            serverMeta = resp.getServerMeta();
            convertSupport = SQLConvertSupport.toSQLConvertSupport(serverMeta.getConvertSupportList());
          } catch (InterruptedException e) {
            throw new SQLException("Interrupted when getting server meta", e);
          } catch (ExecutionException e) {
            Throwable cause =  e.getCause();
            if (cause == null) {
              throw new AssertionError("Something unknown happened", e);
            }
            Throwables.propagateIfPossible(cause);
            throw new SQLException("Error when getting server meta", cause);
          }
        }
      }
    }

    return serverMeta;
  }

  // Note:  Dynamic proxies could be used to reduce the quantity (450?) of
  // method overrides by eliminating those that exist solely to check whether
  // the object is closed.  (Check performance before applying to frequently
  // called ResultSet.)

  // Note:  Methods are in same order as in java.sql.DatabaseMetaData.

  // No isWrapperFor(Class<?>) (it doesn't throw SQLException if already closed).
  // No unwrap(Class<T>) (it doesn't throw SQLException if already closed).

  @Override
  public boolean allProceduresAreCallable() throws SQLException {
    throwIfClosed();
    return super.allProceduresAreCallable();
  }

  @Override
  public boolean allTablesAreSelectable() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.allTablesAreSelectable();
    }
    return getServerMeta().getAllTablesSelectable();
  }

  @Override
  public String getURL() throws SQLException {
    throwIfClosed();
    return super.getURL();
  }

  @Override
  public String getUserName() throws SQLException {
    throwIfClosed();
    return super.getUserName();
  }

  @Override
  public boolean isReadOnly() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.isReadOnly();
    }
    return getServerMeta().getReadOnly();
  }


  // For omitted NULLS FIRST/NULLS HIGH, Drill sort NULL sorts as highest value:

  @Override
  public boolean nullsAreSortedHigh() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return true;
    }
    return getServerMeta().getNullCollation() == NullCollation.NC_HIGH;
  }

  @Override
  public boolean nullsAreSortedLow() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return false;
    }
    return getServerMeta().getNullCollation() == NullCollation.NC_LOW;
  }

  @Override
  public boolean nullsAreSortedAtStart() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return false;
    }
    return getServerMeta().getNullCollation() == NullCollation.NC_AT_START;
  }

  @Override
  public boolean nullsAreSortedAtEnd() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return false;
    }
    return getServerMeta().getNullCollation() == NullCollation.NC_AT_END;
  }

  @Override
  public String getDatabaseProductName() throws SQLException {
    throwIfClosed();
    String name = getServerName();
    if (name == null) {
      return super.getDatabaseProductName();
    }
    return name;
  }

  @Override
  public String getDatabaseProductVersion() throws SQLException {
    throwIfClosed();
    Version version = getServerVersion();
    if (version == null) {
      return super.getDatabaseProductVersion();
    }
    return version.getVersion();
  }

  @Override
  public String getDriverName() throws SQLException {
    throwIfClosed();
    return super.getDriverName();
  }

  @Override
  public String getDriverVersion() throws SQLException {
    throwIfClosed();
    return super.getDriverVersion();
  }

  @Override
  public int getDriverMajorVersion() {
    // No already-closed exception required or allowed by JDBC.
    return super.getDriverMajorVersion();
  }

  @Override
  public int getDriverMinorVersion() {
    // No already-closed exception required or allowed by JDBC.
    return super.getDriverMinorVersion();
  }

  @Override
  public boolean usesLocalFiles() throws SQLException {
    throwIfClosed();
    return super.usesLocalFiles();
  }

  @Override
  public boolean usesLocalFilePerTable() throws SQLException {
    throwIfClosed();
    return super.usesLocalFilePerTable();
  }

  @Override
  public boolean supportsMixedCaseIdentifiers() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsMixedCaseIdentifiers();
    }
    return getServerMeta().getIdentifierCasing() == IdentifierCasing.IC_SUPPORTS_MIXED;
  }

  @Override
  public boolean storesUpperCaseIdentifiers() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.storesUpperCaseIdentifiers();
    }
    return getServerMeta().getIdentifierCasing() == IdentifierCasing.IC_STORES_UPPER;
  }

  @Override
  public boolean storesLowerCaseIdentifiers() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.storesLowerCaseIdentifiers();
    }
    return getServerMeta().getIdentifierCasing() == IdentifierCasing.IC_STORES_LOWER;
  }

  @Override
  public boolean storesMixedCaseIdentifiers() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.storesMixedCaseIdentifiers();
    }
    return getServerMeta().getIdentifierCasing() == IdentifierCasing.IC_STORES_MIXED;
  }

  @Override
  public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsMixedCaseQuotedIdentifiers();
    }
    return getServerMeta().getQuotedIdentifierCasing() == IdentifierCasing.IC_SUPPORTS_MIXED;
  }

  @Override
  public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.storesUpperCaseQuotedIdentifiers();
    }
    return getServerMeta().getQuotedIdentifierCasing() == IdentifierCasing.IC_STORES_UPPER;
  }

  @Override
  public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.storesLowerCaseQuotedIdentifiers();
    }
    return getServerMeta().getQuotedIdentifierCasing() == IdentifierCasing.IC_STORES_LOWER;
  }

  @Override
  public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.storesMixedCaseQuotedIdentifiers();
    }
    return getServerMeta().getQuotedIdentifierCasing() == IdentifierCasing.IC_STORES_MIXED;
  }

  // TODO(DRILL-3510):  Update when Drill accepts standard SQL's double quote.
  @Override
  public String getIdentifierQuoteString() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return "`";
    }
    return getServerMeta().getIdentifierQuoteString();
  }

  @Override
  public String getSQLKeywords() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getSQLKeywords();
    }
    return Joiner.on(",").join(getServerMeta().getSqlKeywordsList());
  }

  @Override
  public String getNumericFunctions() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getNumericFunctions();
    }
    return Joiner.on(",").join(getServerMeta().getNumericFunctionsList());
  }

  @Override
  public String getStringFunctions() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getStringFunctions();
    }
    return Joiner.on(",").join(getServerMeta().getStringFunctionsList());
  }

  @Override
  public String getSystemFunctions() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getSystemFunctions();
    }
    return Joiner.on(",").join(getServerMeta().getSystemFunctionsList());
  }

  @Override
  public String getTimeDateFunctions() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getTimeDateFunctions();
    }
    return Joiner.on(",").join(getServerMeta().getDateTimeFunctionsList());
  }

  @Override
  public String getSearchStringEscape() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getSearchStringEscape();
    }
    return getServerMeta().getSearchEscapeString();
  }

  @Override
  public String getExtraNameCharacters() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getExtraNameCharacters();
    }
    return getServerMeta().getSpecialCharacters();
  }

  @Override
  public boolean supportsAlterTableWithAddColumn() throws SQLException {
    throwIfClosed();
    return super.supportsAlterTableWithAddColumn();
  }

  @Override
  public boolean supportsAlterTableWithDropColumn() throws SQLException {
    throwIfClosed();
    return super.supportsAlterTableWithDropColumn();
  }

  @Override
  public boolean supportsColumnAliasing() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsColumnAliasing();
    }
    return getServerMeta().getColumnAliasingSupported();
  }

  @Override
  public boolean nullPlusNonNullIsNull() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.nullPlusNonNullIsNull();
    }
    return getServerMeta().getNullPlusNonNullEqualsNull();
  }

  @Override
  public boolean supportsConvert() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsConvert();
    }
    // Make sure the convert table is loaded
    getServerMeta();
    return !convertSupport.isEmpty();
  }

  @Override
  public boolean supportsConvert(int fromType, int toType) throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsConvert(fromType, toType);
    }
    // Make sure the convert table is loaded
    getServerMeta();
    return convertSupport.contains(new SQLConvertSupport(fromType, toType));
  }

  @Override
  public boolean supportsTableCorrelationNames() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsTableCorrelationNames();
    }
    return getServerMeta().getCorrelationNamesSupport() == CorrelationNamesSupport.CN_ANY
        || getServerMeta().getCorrelationNamesSupport() == CorrelationNamesSupport.CN_DIFFERENT_NAMES;
  }

  @Override
  public boolean supportsDifferentTableCorrelationNames() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsDifferentTableCorrelationNames();
    }
    return getServerMeta().getCorrelationNamesSupport() == CorrelationNamesSupport.CN_DIFFERENT_NAMES;
  }

  @Override
  public boolean supportsExpressionsInOrderBy() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsExpressionsInOrderBy();
    }
    return getServerMeta().getOrderBySupportList().contains(OrderBySupport.OB_EXPRESSION);
  }

  @Override
  public boolean supportsOrderByUnrelated() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsOrderByUnrelated();
    }
    return getServerMeta().getOrderBySupportList().contains(OrderBySupport.OB_UNRELATED);
  }

  @Override
  public boolean supportsGroupBy() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsGroupBy();
    }
    return getServerMeta().getGroupBySupport() != GroupBySupport.GB_NONE;
  }

  @Override
  public boolean supportsGroupByUnrelated() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsGroupByUnrelated();
    }
    return getServerMeta().getGroupBySupport() == GroupBySupport.GB_UNRELATED;
  }

  @Override
  public boolean supportsGroupByBeyondSelect() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsGroupByBeyondSelect();
    }
    return getServerMeta().getGroupBySupport() == GroupBySupport.GB_BEYOND_SELECT;
  }

  @Override
  public boolean supportsLikeEscapeClause() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsLikeEscapeClause();
    }
    return getServerMeta().getLikeEscapeClauseSupported();
  }

  @Override
  public boolean supportsMultipleResultSets() throws SQLException {
    throwIfClosed();
    return super.supportsMultipleResultSets();
  }

  @Override
  public boolean supportsMultipleTransactions() throws SQLException {
    throwIfClosed();
    return super.supportsMultipleTransactions();
  }

  @Override
  public boolean supportsNonNullableColumns() throws SQLException {
    throwIfClosed();
    return super.supportsNonNullableColumns();
  }

  @Override
  public boolean supportsMinimumSQLGrammar() throws SQLException {
    throwIfClosed();
    return super.supportsMinimumSQLGrammar();
  }

  @Override
  public boolean supportsCoreSQLGrammar() throws SQLException {
    throwIfClosed();
    return super.supportsCoreSQLGrammar();
  }

  @Override
  public boolean supportsExtendedSQLGrammar() throws SQLException {
    throwIfClosed();
    return super.supportsExtendedSQLGrammar();
  }

  @Override
  public boolean supportsANSI92EntryLevelSQL() throws SQLException {
    throwIfClosed();
    return super.supportsANSI92EntryLevelSQL();
  }

  @Override
  public boolean supportsANSI92IntermediateSQL() throws SQLException {
    throwIfClosed();
    return super.supportsANSI92IntermediateSQL();
  }

  @Override
  public boolean supportsANSI92FullSQL() throws SQLException {
    throwIfClosed();
    return super.supportsANSI92FullSQL();
  }

  @Override
  public boolean supportsIntegrityEnhancementFacility() throws SQLException {
    throwIfClosed();
    return super.supportsIntegrityEnhancementFacility();
  }

  @Override
  public boolean supportsOuterJoins() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsOuterJoins();
    }
    return getServerMeta().getOuterJoinSupportCount() > 0;
  }

  @Override
  public boolean supportsFullOuterJoins() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsFullOuterJoins();
    }
    return getServerMeta().getOuterJoinSupportList().contains(OuterJoinSupport.OJ_FULL);
  }

  @Override
  public boolean supportsLimitedOuterJoins() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsFullOuterJoins();
    }
    return getServerMeta().getOuterJoinSupportCount() > 0
        && !(getServerMeta().getOuterJoinSupportList().contains(OuterJoinSupport.OJ_FULL));
  }

  @Override
  public String getSchemaTerm() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getSchemaTerm();
    }
    return getServerMeta().getSchemaTerm();
  }

  @Override
  public String getProcedureTerm() throws SQLException {
    throwIfClosed();
    return super.getProcedureTerm();
  }

  @Override
  public String getCatalogTerm() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getCatalogTerm();
    }
    return getServerMeta().getCatalogTerm();
  }

  @Override
  public boolean isCatalogAtStart() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.isCatalogAtStart();
    }
    return getServerMeta().getCatalogAtStart();
  }

  @Override
  public String getCatalogSeparator() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getCatalogSeparator();
    }
    return getServerMeta().getCatalogSeparator();
  }

  @Override
  public boolean supportsSchemasInDataManipulation() throws SQLException {
    throwIfClosed();
    return super.supportsSchemasInDataManipulation();
  }

  @Override
  public boolean supportsSchemasInProcedureCalls() throws SQLException {
    throwIfClosed();
    return super.supportsSchemasInProcedureCalls();
  }

  @Override
  public boolean supportsSchemasInTableDefinitions() throws SQLException {
    throwIfClosed();
    return super.supportsSchemasInTableDefinitions();
  }

  @Override
  public boolean supportsSchemasInIndexDefinitions() throws SQLException {
    throwIfClosed();
    return super.supportsSchemasInIndexDefinitions();
  }

  @Override
  public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
    throwIfClosed();
    return super.supportsSchemasInPrivilegeDefinitions();
  }

  @Override
  public boolean supportsCatalogsInDataManipulation() throws SQLException {
    throwIfClosed();
    return super.supportsCatalogsInDataManipulation();
  }

  @Override
  public boolean supportsCatalogsInProcedureCalls() throws SQLException {
    throwIfClosed();
    return super.supportsCatalogsInProcedureCalls();
  }

  @Override
  public boolean supportsCatalogsInTableDefinitions() throws SQLException {
    throwIfClosed();
    return super.supportsCatalogsInTableDefinitions();
  }

  @Override
  public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
    throwIfClosed();
    return super.supportsCatalogsInIndexDefinitions();
  }

  @Override
  public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
    throwIfClosed();
    return super.supportsCatalogsInPrivilegeDefinitions();
  }

  @Override
  public boolean supportsPositionedDelete() throws SQLException {
    throwIfClosed();
    return super.supportsPositionedDelete();
  }

  @Override
  public boolean supportsPositionedUpdate() throws SQLException {
    throwIfClosed();
    return super.supportsPositionedUpdate();
  }

  @Override
  public boolean supportsSelectForUpdate() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsSelectForUpdate();
    }
    return getServerMeta().getSelectForUpdateSupported();
  }

  @Override
  public boolean supportsStoredProcedures() throws SQLException {
    throwIfClosed();
    return super.supportsStoredProcedures();
  }

  @Override
  public boolean supportsSubqueriesInComparisons() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsSubqueriesInComparisons();
    }
    return getServerMeta().getSubquerySupportList().contains(SubQuerySupport.SQ_IN_COMPARISON);
  }

  @Override
  public boolean supportsSubqueriesInExists() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsSubqueriesInExists();
    }
    return getServerMeta().getSubquerySupportList().contains(SubQuerySupport.SQ_IN_EXISTS);
  }

  @Override
  public boolean supportsSubqueriesInIns() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsSubqueriesInIns();
    }
    return getServerMeta().getSubquerySupportList().contains(SubQuerySupport.SQ_IN_INSERT);
  }

  @Override
  public boolean supportsSubqueriesInQuantifieds() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsSubqueriesInQuantifieds();
    }
    return getServerMeta().getSubquerySupportList().contains(SubQuerySupport.SQ_IN_QUANTIFIED);
  }

  @Override
  public boolean supportsCorrelatedSubqueries() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsCorrelatedSubqueries();
    }
    return getServerMeta().getSubquerySupportList().contains(SubQuerySupport.SQ_CORRELATED);
  }

  @Override
  public boolean supportsUnion() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsUnion();
    }
    return getServerMeta().getUnionSupportList().contains(UnionSupport.U_UNION);
  }

  @Override
  public boolean supportsUnionAll() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsUnionAll();
    }
    return getServerMeta().getUnionSupportList().contains(UnionSupport.U_UNION_ALL);
  }

  @Override
  public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
    throwIfClosed();
    return super.supportsOpenCursorsAcrossCommit();
  }

  @Override
  public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
    throwIfClosed();
    return super.supportsOpenCursorsAcrossRollback();
  }

  @Override
  public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
    throwIfClosed();
    return super.supportsOpenStatementsAcrossCommit();
  }

  @Override
  public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
    throwIfClosed();
    return super.supportsOpenStatementsAcrossRollback();
  }

  @Override
  public int getMaxBinaryLiteralLength() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxBinaryLiteralLength();
    }
    return getServerMeta().getMaxBinaryLiteralLength();
  }

  @Override
  public int getMaxCharLiteralLength() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxCharLiteralLength();
    }
    return getServerMeta().getMaxCharLiteralLength();
  }

  @Override
  public int getMaxColumnNameLength() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxColumnNameLength();
    }
    return getServerMeta().getMaxColumnNameLength();
  }

  @Override
  public int getMaxColumnsInGroupBy() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxColumnsInGroupBy();
    }
    return getServerMeta().getMaxColumnsInGroupBy();
  }

  @Override
  public int getMaxColumnsInIndex() throws SQLException {
    throwIfClosed();
    return super.getMaxColumnsInIndex();
  }

  @Override
  public int getMaxColumnsInOrderBy() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxColumnsInOrderBy();
    }
    return getServerMeta().getMaxColumnsInOrderBy();
  }

  @Override
  public int getMaxColumnsInSelect() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxColumnsInSelect();
    }
    return getServerMeta().getMaxColumnsInSelect();
  }

  @Override
  public int getMaxColumnsInTable() throws SQLException {
    throwIfClosed();
    return super.getMaxColumnsInTable();
  }

  @Override
  public int getMaxConnections() throws SQLException {
    throwIfClosed();
    return super.getMaxConnections();
  }

  @Override
  public int getMaxCursorNameLength() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxCursorNameLength();
    }
    return getServerMeta().getMaxCursorNameLength();
  }

  @Override
  public int getMaxIndexLength() throws SQLException {
    throwIfClosed();
    return super.getMaxIndexLength();
  }

  @Override
  public int getMaxSchemaNameLength() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxSchemaNameLength();
    }
    return getServerMeta().getMaxSchemaNameLength();
  }

  @Override
  public int getMaxProcedureNameLength() throws SQLException {
    throwIfClosed();
    return super.getMaxProcedureNameLength();
  }

  @Override
  public int getMaxCatalogNameLength() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxCatalogNameLength();
    }
    return getServerMeta().getMaxCatalogNameLength();
  }

  @Override
  public int getMaxRowSize() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxRowSize();
    }
    return getServerMeta().getMaxRowSize();
  }

  @Override
  public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.doesMaxRowSizeIncludeBlobs();
    }
    return getServerMeta().getBlobIncludedInMaxRowSize();
  }

  @Override
  public int getMaxStatementLength() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxStatementLength();
    }
    return getServerMeta().getMaxStatementLength();
  }

  @Override
  public int getMaxStatements() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxStatements();
    }
    return getServerMeta().getMaxStatements();
  }

  @Override
  public int getMaxTableNameLength() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxTableNameLength();
    }
    return getServerMeta().getMaxTableNameLength();
  }

  @Override
  public int getMaxTablesInSelect() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxTablesInSelect();
    }
    return getServerMeta().getMaxTablesInSelect();
  }

  @Override
  public int getMaxUserNameLength() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.getMaxUserNameLength();
    }
    return getServerMeta().getMaxUserNameLength();
  }

  @Override
  public int getDefaultTransactionIsolation() throws SQLException {
    throwIfClosed();
    return super.getDefaultTransactionIsolation();
  }

  @Override
  public boolean supportsTransactions() throws SQLException {
    throwIfClosed();
    if (!getServerMetaSupported()) {
      return super.supportsTransactions();
    }
    return getServerMeta().getTransactionSupported();
  }

  @Override
  public boolean supportsTransactionIsolationLevel(int level) throws SQLException {
    throwIfClosed();
    return super.supportsTransactionIsolationLevel(level);
  }

  @Override
  public boolean supportsDataDefinitionAndDataManipulationTransactions()
      throws SQLException {
    throwIfClosed();
    return super.supportsDataDefinitionAndDataManipulationTransactions();
  }

  @Override
  public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
    throwIfClosed();
    return super.supportsDataManipulationTransactionsOnly();
  }

  @Override
  public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
    throwIfClosed();
    return super.dataDefinitionCausesTransactionCommit();
  }

  @Override
  public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
    throwIfClosed();
    return super.dataDefinitionIgnoredInTransactions();
  }

  @Override
  public ResultSet getProcedures(String catalog, String schemaPattern,
                                 String procedureNamePattern) throws SQLException {
    throwIfClosed();
    return super.getProcedures(catalog, schemaPattern, procedureNamePattern);
  }

  @Override
  public ResultSet getProcedureColumns(String catalog, String schemaPattern,
                                       String procedureNamePattern,
                                       String columnNamePattern) throws SQLException {
    throwIfClosed();
    return super.getProcedureColumns(catalog, schemaPattern,
                                     procedureNamePattern, columnNamePattern);
  }

  @Override
  public ResultSet getTables(String catalog,
                             String schemaPattern,
                             String tableNamePattern,
                             String[] types) throws SQLException {
    throwIfClosed();
    try {
      return super.getTables(catalog, schemaPattern,tableNamePattern, types);
    } catch(DrillRuntimeException e) {
      Throwables.propagateIfInstanceOf(e.getCause(), SQLException.class);
      throw e;
    }
  }


  @Override
  public ResultSet getSchemas() throws SQLException {
    throwIfClosed();
    try {
      return super.getSchemas();
    } catch(DrillRuntimeException e) {
      Throwables.propagateIfInstanceOf(e.getCause(), SQLException.class);
      throw e;
    }
  }

  @Override
  public ResultSet getCatalogs() throws SQLException {
    throwIfClosed();
    try {
      return super.getCatalogs();
    } catch(DrillRuntimeException e) {
      Throwables.propagateIfInstanceOf(e.getCause(), SQLException.class);
      throw e;
    }
  }

  @Override
  public ResultSet getTableTypes() throws SQLException {
    throwIfClosed();
    return super.getTableTypes();
  }

  @Override
  public ResultSet getColumns(String catalog, String schema, String table,
                              String columnNamePattern) throws SQLException {
    throwIfClosed();
    try {
      return super.getColumns(catalog, schema, table, columnNamePattern);
    } catch(DrillRuntimeException e) {
      Throwables.propagateIfInstanceOf(e.getCause(), SQLException.class);
      throw e;
    }
  }

  @Override
  public ResultSet getColumnPrivileges(String catalog, String schema,
                                       String table,
                                       String columnNamePattern) throws SQLException {
    throwIfClosed();
    return super.getColumnPrivileges(catalog, schema, table, columnNamePattern);
  }

  @Override
  public ResultSet getTablePrivileges(String catalog, String schemaPattern,
                                      String tableNamePattern) throws SQLException {
    throwIfClosed();
    return super.getTablePrivileges(catalog, schemaPattern, tableNamePattern);
  }

  @Override
  public ResultSet getBestRowIdentifier(String catalog, String schema,
                                        String table, int scope,
                                        boolean nullable) throws SQLException {
    throwIfClosed();
    return super.getBestRowIdentifier(catalog, schema, table, scope, nullable);
  }

  @Override
  public ResultSet getVersionColumns(String catalog, String schema,
                                     String table) throws SQLException {
    throwIfClosed();
    return super.getVersionColumns(catalog, schema, table);
  }

  @Override
  public ResultSet getPrimaryKeys(String catalog, String schema,
                                  String table) throws SQLException {
    throwIfClosed();
    return super.getPrimaryKeys(catalog, schema, table);
  }

  @Override
  public ResultSet getImportedKeys(String catalog, String schema,
                                   String table) throws SQLException {
    throwIfClosed();
    return super.getImportedKeys(catalog, schema, table);
  }

  @Override
  public ResultSet getExportedKeys(String catalog, String schema,
                                   String table) throws SQLException {
    throwIfClosed();
    return super.getExportedKeys(catalog, schema, table);
  }

  @Override
  public ResultSet getCrossReference(
      String parentCatalog, String parentSchema, String parentTable,
      String foreignCatalog, String foreignSchema,
      String foreignTable ) throws SQLException {
    throwIfClosed();
    return super.getCrossReference(parentCatalog, parentSchema, parentTable,
                                   foreignCatalog, foreignSchema, foreignTable );
  }

  @Override
  public ResultSet getTypeInfo() throws SQLException {
    throwIfClosed();
    return super.getTypeInfo();
  }

  @Override
  public ResultSet getIndexInfo(String catalog, String schema, String table,
                                boolean unique,
                                boolean approximate) throws SQLException {
    throwIfClosed();
    return super.getIndexInfo(catalog, schema, table, unique, approximate);
  }

  @Override
  public boolean supportsResultSetType(int type) throws SQLException {
    throwIfClosed();
    return super.supportsResultSetType(type);
  }

  @Override
  public boolean supportsResultSetConcurrency(int type,
                                              int concurrency) throws SQLException {
    throwIfClosed();
    return super.supportsResultSetConcurrency(type, concurrency);
  }

  @Override
  public boolean ownUpdatesAreVisible(int type) throws SQLException {
    throwIfClosed();
    try {
      return super.ownUpdatesAreVisible(type);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "ownUpdatesAreVisible(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public boolean ownDeletesAreVisible(int type) throws SQLException {
    throwIfClosed();
    try {
      return super.ownDeletesAreVisible(type);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "ownDeletesAreVisible(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public boolean ownInsertsAreVisible(int type) throws SQLException {
    throwIfClosed();
    try {
      return super.ownInsertsAreVisible(type);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "ownInsertsAreVisible(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public boolean othersUpdatesAreVisible(int type) throws SQLException {
    throwIfClosed();
    try {
      return super.othersUpdatesAreVisible(type);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "othersUpdatesAreVisible(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public boolean othersDeletesAreVisible(int type) throws SQLException {
    throwIfClosed();
    try {
      return super.othersDeletesAreVisible(type);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "othersDeletesAreVisible(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public boolean othersInsertsAreVisible(int type) throws SQLException {
    throwIfClosed();
    try {
      return super.othersInsertsAreVisible(type);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "othersInsertsAreVisible(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public boolean updatesAreDetected(int type) throws SQLException {
    throwIfClosed();
    try {
      return super.updatesAreDetected(type);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "updatesAreDetected(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public boolean deletesAreDetected(int type) throws SQLException {
    throwIfClosed();
    try {
      return super.deletesAreDetected(type);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "deletesAreDetected(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public boolean insertsAreDetected(int type) throws SQLException {
    throwIfClosed();
    try {
      return super.insertsAreDetected(type);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "insertsAreDetected(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public boolean supportsBatchUpdates() throws SQLException {
    throwIfClosed();
    return super.supportsBatchUpdates();
  }

  @Override
  public ResultSet getUDTs(String catalog, String schemaPattern,
                           String typeNamePattern,
                           int[] types) throws SQLException {
    throwIfClosed();
    return super.getUDTs(catalog, schemaPattern, typeNamePattern, types);
  }

  @Override
  public Connection getConnection() throws SQLException {
    // No already-closed exception required by JDBC.
    return super.getConnection();
  }

  @Override
  public boolean supportsSavepoints() throws SQLException {
    throwIfClosed();
    return super.supportsSavepoints();
  }

  @Override
  public boolean supportsNamedParameters() throws SQLException {
    throwIfClosed();
    return super.supportsNamedParameters();
  }

  @Override
  public boolean supportsMultipleOpenResults() throws SQLException {
    throwIfClosed();
    return super.supportsMultipleOpenResults();
  }

  @Override
  public boolean supportsGetGeneratedKeys() throws SQLException {
    throwIfClosed();
    return super.supportsGetGeneratedKeys();
  }

  @Override
  public ResultSet getSuperTypes(String catalog, String schemaPattern,
                                 String typeNamePattern) throws SQLException {
    throwIfClosed();
    return super.getSuperTypes(catalog, schemaPattern, typeNamePattern);
  }

  @Override
  public ResultSet getSuperTables(String catalog, String schemaPattern,
                                  String tableNamePattern) throws SQLException {
    throwIfClosed();
    return super.getSuperTables(catalog, schemaPattern, tableNamePattern);
  }

  @Override
  public ResultSet getAttributes(String catalog, String schemaPattern,
                                 String typeNamePattern,
                                 String attributeNamePattern) throws SQLException {
    throwIfClosed();
    return super.getAttributes(catalog, schemaPattern, typeNamePattern,
                               attributeNamePattern);
  }

  @Override
  public boolean supportsResultSetHoldability(int holdability) throws SQLException {
    throwIfClosed();
    try {
      return super.supportsResultSetHoldability(holdability);
    }
    catch (RuntimeException e) {
      if ("todo: implement this method".equals(e.getMessage())) {
        throw new SQLFeatureNotSupportedException(
            "supportsResultSetHoldability(int) is not supported", e);
      }
      else {
        throw new SQLException(e.getMessage(), e);
      }
    }
  }

  @Override
  public int getResultSetHoldability() {
    // Can't throw any SQLException because Avatica's getResultSetHoldability()
    // is missing "throws SQLException".
    try {
      throwIfClosed();
    } catch (AlreadyClosedSqlException e) {
      throw new RuntimeException(e.getMessage(), e);
    } catch (SQLException e) {
      throw new RuntimeException(e.getMessage(), e);
    }
    return super.getResultSetHoldability();
  }

  @Override
  public int getDatabaseMajorVersion() throws SQLException {
    throwIfClosed();
    Version version = getServerVersion();
    if (version == null) {
      return super.getDatabaseMajorVersion();
    }
    return version.getMajorVersion();
  }

  @Override
  public int getDatabaseMinorVersion() throws SQLException {
    throwIfClosed();
    Version version = getServerVersion();
    if (version == null) {
      return super.getDatabaseMinorVersion();
    }
    return version.getMinorVersion();
  }

  @Override
  public int getJDBCMajorVersion() throws SQLException {
    throwIfClosed();
    return super.getJDBCMajorVersion();
  }

  @Override
  public int getJDBCMinorVersion() throws SQLException {
    throwIfClosed();
    return super.getJDBCMinorVersion();
  }

  @Override
  public int getSQLStateType() throws SQLException {
    throwIfClosed();
    return super.getSQLStateType();
  }

  @Override
  public boolean locatorsUpdateCopy() throws SQLException {
    throwIfClosed();
    return super.locatorsUpdateCopy();
  }

  @Override
  public boolean supportsStatementPooling() throws SQLException {
    throwIfClosed();
    return super.supportsStatementPooling();
  }

  @Override
  public RowIdLifetime getRowIdLifetime() throws SQLException {
    throwIfClosed();
    return super.getRowIdLifetime();
  }

  @Override
  public ResultSet getSchemas(String catalog,
                              String schemaPattern) throws SQLException {
    throwIfClosed();
    return super.getSchemas(catalog, schemaPattern);
  }

  @Override
  public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
    throwIfClosed();
    return super.supportsStoredFunctionsUsingCallSyntax();
  }

  @Override
  public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
    throwIfClosed();
    return super.autoCommitFailureClosesAllResultSets();
  }

  @Override
  public ResultSet getClientInfoProperties() throws SQLException {
    throwIfClosed();
    return super.getClientInfoProperties();
  }

  @Override
  public ResultSet getFunctions(String catalog, String schemaPattern,
                                String functionNamePattern) throws SQLException {
    throwIfClosed();
    return super.getFunctions(catalog, schemaPattern, functionNamePattern);
  }

  @Override
  public ResultSet getFunctionColumns(String catalog, String schemaPattern,
                                      String functionNamePattern,
                                      String columnNamePattern) throws SQLException {
    throwIfClosed();
    return super.getFunctionColumns(catalog, schemaPattern, functionNamePattern,
                                    columnNamePattern);
  }

  @Override
  public ResultSet getPseudoColumns(String catalog, String schemaPattern,
                                    String tableNamePattern,
                                    String columnNamePattern) throws SQLException {
    throwIfClosed();
    return super.getPseudoColumns(catalog, schemaPattern, tableNamePattern,
                                  columnNamePattern);
  }

  @Override
  public boolean generatedKeyAlwaysReturned() throws SQLException {
    throwIfClosed();
    return super.generatedKeyAlwaysReturned();
  }


}