drill-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From par...@apache.org
Subject [06/10] drill git commit: DRILL-3216: Part 2--Fix existing(+) INFORMATION_SCHEMA.COLUMNS columns.
Date Wed, 17 Jun 2015 20:30:36 GMT
http://git-wip-us.apache.org/repos/asf/drill/blob/c668a10d/exec/jdbc/src/test/java/org/apache/drill/jdbc/test/TestInformationSchemaColumns.java
----------------------------------------------------------------------
diff --git a/exec/jdbc/src/test/java/org/apache/drill/jdbc/test/TestInformationSchemaColumns.java b/exec/jdbc/src/test/java/org/apache/drill/jdbc/test/TestInformationSchemaColumns.java
new file mode 100644
index 0000000..3f820f5
--- /dev/null
+++ b/exec/jdbc/src/test/java/org/apache/drill/jdbc/test/TestInformationSchemaColumns.java
@@ -0,0 +1,2626 @@
+/**
+ * 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.test;
+
+import static org.junit.Assert.fail;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.hamcrest.CoreMatchers.*;
+
+import org.apache.drill.jdbc.Driver;
+import org.apache.drill.jdbc.JdbcTestBase;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+
+import static java.sql.ResultSetMetaData.columnNoNulls;
+import static java.sql.ResultSetMetaData.columnNullable;
+
+import java.sql.SQLException;
+import java.sql.Types;
+
+// NOTE: TempInformationSchemaColumnsTest and DatabaseMetaDataGetColumnsTest
+// have identical sections.  (Cross-maintain them for now; factor out later.)
+
+// TODO:  Review nullability (NULLABLE and IS_NULLABLE columns):
+// - It's not clear why Drill sets INFORMATION_SCHEMA.COLUMNS.IS_NULLABLE to
+// 'NO' for some columns that contain only null (e.g., for
+// "CREATE VIEW x AS SELECT CAST(NULL AS ...) ..."
+
+
+/**
+ * Test class for Drill's INFORMATION_SCHEMA.COLUMNS implementation.
+ */
+public class TestInformationSchemaColumns extends JdbcTestBase {
+
+  private static final String VIEW_SCHEMA = "dfs_test.tmp";
+  private static final String VIEW_NAME =
+      TestInformationSchemaColumns.class.getSimpleName() + "_View";
+
+
+  /** The one shared JDBC connection to Drill. */
+  private static Connection connection;
+
+
+  /** Result set metadata.  For checking columns themselves (not cell
+   *  values or row order). */
+  private static ResultSetMetaData rowsMetadata;
+
+
+  ////////////////////
+  // Results from INFORMATION_SCHEMA.COLUMN for test columns of various types.
+  // Each ResultSet is positioned at first row for, and must not be modified by,
+  // test methods.
+
+  //////////
+  // For columns in temporary test view (types accessible via casting):
+
+  private static ResultSet mdrOptBOOLEAN;
+
+  private static ResultSet mdrReqTINYINT;
+  private static ResultSet mdrOptSMALLINT;
+  private static ResultSet mdrReqINTEGER;
+  private static ResultSet mdrOptBIGINT;
+
+  private static ResultSet mdrOptREAL;
+  private static ResultSet mdrOptFLOAT;
+  private static ResultSet mdrReqDOUBLE;
+
+  private static ResultSet mdrReqDECIMAL_5_3;
+  // No NUMERIC while Drill just maps it to DECIMAL.
+
+  private static ResultSet mdrReqVARCHAR_10;
+  private static ResultSet mdrOptVARCHAR;
+  private static ResultSet mdrReqCHAR_5;
+  // No NCHAR, etc., in Drill (?).
+  private static ResultSet mdrOptVARBINARY_16;
+  private static ResultSet mdrOptBINARY_1048576;
+
+  private static ResultSet mdrReqDATE;
+  private static ResultSet mdrReqTIME;
+  private static ResultSet mdrOptTIME_7;
+  private static ResultSet mdrOptTIMESTAMP;
+  // No "... WITH TIME ZONE" in Drill.
+
+  private static ResultSet mdrReqINTERVAL_Y;
+  private static ResultSet mdrReqINTERVAL_3Y_Mo;
+  private static ResultSet mdrReqINTERVAL_Mo;
+  private static ResultSet mdrReqINTERVAL_D;
+  private static ResultSet mdrReqINTERVAL_4D_H;
+  private static ResultSet mdrReqINTERVAL_3D_Mi;
+  private static ResultSet mdrReqINTERVAL_2D_S5;
+  private static ResultSet mdrReqINTERVAL_H;
+  private static ResultSet mdrReqINTERVAL_1H_Mi;
+  private static ResultSet mdrReqINTERVAL_3H_S1;
+  private static ResultSet mdrReqINTERVAL_Mi;
+  private static ResultSet mdrReqINTERVAL_5Mi_S;
+  private static ResultSet mdrReqINTERVAL_S;
+  private static ResultSet mdrReqINTERVAL_3S;
+  private static ResultSet mdrReqINTERVAL_3S1;
+
+  // For columns in schema hive_test.default's infoschematest table:
+
+  // listtype column:      VARCHAR(65535) ARRAY, non-null(?):
+  private static ResultSet mdrReqARRAY;
+  // maptype column:       (VARCHAR(65535), INTEGER) MAP, non-null(?):
+  private static ResultSet mdrReqMAP;
+  // structtype column:    STRUCT(INTEGER sint, BOOLEAN sboolean,
+  //                              VARCHAR(65535) sstring), non-null(?):
+  private static ResultSet mdrUnkSTRUCT;
+  // uniontypetype column: OTHER (?), non=nullable(?):
+  private static ResultSet mdrUnkUnion;
+
+
+  /**
+   * Gets SQL <character string literal> representing given string value.
+   * <p>
+   *    (Encodes {@code '} as {@code ''} and every other character as itself.)
+   * </p>
+   */
+  private static String encodeAsSqlCharStrLiteral( String value ) {
+    return "'" + value.replaceAll( "'", "''" ) + "'";
+  }
+
+
+  private static ResultSet setUpRow( final String schemaName,
+                                     final String tableOrViewName,
+                                     final String columnName ) throws SQLException
+  {
+    System.out.println( "(Setting up row for " + tableOrViewName + "." + columnName + ".)");
+    final Statement stmt = connection.createStatement();
+    final ResultSet mdrUnk =
+        stmt.executeQuery(
+            "SELECT * FROM INFORMATION_SCHEMA.COLUMNS "
+            + "WHERE TABLE_CATALOG = " + encodeAsSqlCharStrLiteral( "DRILL" )
+            + "  AND TABLE_SCHEMA  = " + encodeAsSqlCharStrLiteral( schemaName )
+            + "  AND TABLE_NAME    = " + encodeAsSqlCharStrLiteral( tableOrViewName )
+            + "  AND COLUMN_NAME   = " + encodeAsSqlCharStrLiteral( columnName )
+            );
+    assertTrue( "Test setup error:  No row for column DRILL . `" + schemaName + "` . `"
+                + tableOrViewName + "` . `" + columnName + "`", mdrUnk.next() );
+    return mdrUnk;
+  }
+
+  @BeforeClass
+  public static void setUpConnectionAndMetadataToCheck() throws Exception {
+
+    // Get JDBC connection to Drill:
+    // (Note: Can't use JdbcTest's connect(...) because JdbcTest closes
+    // Connection--and other JDBC objects--on test method failure, but this test
+    // class uses some objects across methods.)
+    connection = new Driver().connect( "jdbc:drill:zk=local", JdbcAssert.getDefaultProperties() );
+    final Statement stmt = connection.createStatement();
+
+    ResultSet util;
+
+    /* TODO(DRILL-3253)(start): Update this once we have test plugin supporting all needed types.
+    // Create Hive test data, only if not created already (speed optimization):
+    util = stmt.executeQuery( "SELECT * FROM INFORMATION_SCHEMA.COLUMNS "
+                              + "WHERE TABLE_SCHEMA = 'hive_test.default' "
+                              + "  AND TABLE_NAME = 'infoschematest'" );
+
+    System.out.println( "(Hive infoschematest columns: " );
+    int hiveTestColumnRowCount = 0;
+    while ( util.next() ) {
+      hiveTestColumnRowCount++;
+      System.out.println(
+          " Hive test column: "
+          + util.getString( 1 ) + " - " + util.getString( 2 ) + " - "
+          + util.getString( 3 ) + " - " + util.getString( 4 ) );
+    }
+    System.out.println( " Hive test column count: " + hiveTestColumnRowCount + ")" );
+    if ( 0 == hiveTestColumnRowCount ) {
+      // No Hive test data--create it.
+      new HiveTestDataGenerator().generateTestData();
+    } else if ( 17 == hiveTestColumnRowCount ) {
+      // Hive data seems to exist already--skip recreating it.
+    } else {
+      fail("Expected 17 Hive test columns see " + hiveTestColumnRowCount + "."
+            + "  Test code is out of date or Hive data is corrupted.");
+    }
+    TODO(DRILL-3253)(end) */
+
+    // Create temporary test-columns view:
+    util = stmt.executeQuery( "USE dfs_test.tmp" );
+    assertTrue( util.next() );
+    assertTrue( "Error setting schema for test: " + util.getString( 2 ), util.getBoolean( 1 ) );
+    util = stmt.executeQuery(
+        ""
+        +   "CREATE OR REPLACE VIEW " + VIEW_NAME + " AS SELECT "
+        + "\n  CAST( NULL    AS BOOLEAN            ) AS mdrOptBOOLEAN,        "
+        + "\n  "
+        + "\n  CAST(    1    AS TINYINT            ) AS mdrReqTINYINT,        "
+        + "\n  CAST( NULL    AS SMALLINT           ) AS mdrOptSMALLINT,       "
+        + "\n  CAST(    2    AS INTEGER            ) AS mdrReqINTEGER,        "
+        + "\n  CAST( NULL    AS BIGINT             ) AS mdrOptBIGINT,         "
+        + "\n  "
+        + "\n  CAST( NULL    AS REAL               ) AS mdrOptREAL,           "
+        + "\n  CAST( NULL    AS FLOAT              ) AS mdrOptFLOAT,          "
+        + "\n  CAST(  3.3    AS DOUBLE             ) AS mdrReqDOUBLE,         "
+        + "\n  "
+        + "\n  CAST(  4.4    AS DECIMAL(5,3)       ) AS mdrReqDECIMAL_5_3,    "
+        + "\n  "
+        + "\n  CAST( 'Hi'    AS VARCHAR(10)        ) AS mdrReqVARCHAR_10,     "
+        + "\n  CAST( NULL    AS VARCHAR            ) AS mdrOptVARCHAR,        "
+        + "\n  CAST( '55'    AS CHAR(5)            ) AS mdrReqCHAR_5,         "
+        + "\n  CAST( NULL    AS VARBINARY(16)      ) AS mdrOptVARBINARY_16,   "
+        + "\n  CAST( NULL    AS VARBINARY(1048576) ) AS mdrOptBINARY_1048576, "
+        + "\n  CAST( NULL    AS BINARY(8)          ) AS mdrOptBINARY_8,       "
+        + "\n  "
+        + "\n                   DATE '2015-01-01'    AS mdrReqDATE,           "
+        + "\n                   TIME '23:59:59'      AS mdrReqTIME,           "
+        + "\n  CAST( NULL    AS TIME(7)            ) AS mdrOptTIME_7,         "
+        + "\n  CAST( NULL    AS TIMESTAMP          ) AS mdrOptTIMESTAMP,      "
+        + "\n  INTERVAL '1'     YEAR                 AS mdrReqINTERVAL_Y,     "
+        + "\n  INTERVAL '1-2'   YEAR(3) TO MONTH     AS mdrReqINTERVAL_3Y_Mo, "
+        + "\n  INTERVAL '2'     MONTH                AS mdrReqINTERVAL_Mo,    "
+        + "\n  INTERVAL '3'     DAY                  AS mdrReqINTERVAL_D,     "
+        + "\n  INTERVAL '3 4'   DAY(4) TO HOUR       AS mdrReqINTERVAL_4D_H,  "
+        + "\n  INTERVAL '3 4:5' DAY(3) TO MINUTE     AS mdrReqINTERVAL_3D_Mi, "
+        + "\n  INTERVAL '3 4:5:6' DAY(2) TO SECOND(5) AS mdrReqINTERVAL_2D_S5, "
+        + "\n  INTERVAL '4'     HOUR                 AS mdrReqINTERVAL_H,     "
+        + "\n  INTERVAL '4:5'   HOUR(1) TO MINUTE    AS mdrReqINTERVAL_1H_Mi, "
+        + "\n  INTERVAL '4:5:6' HOUR(3) TO SECOND(1) AS mdrReqINTERVAL_3H_S1, "
+        + "\n  INTERVAL '5'     MINUTE               AS mdrReqINTERVAL_Mi,    "
+        + "\n  INTERVAL '5:6'   MINUTE(5) TO SECOND  AS mdrReqINTERVAL_5Mi_S, "
+        + "\n  INTERVAL '6'     SECOND               AS mdrReqINTERVAL_S,     "
+        + "\n  INTERVAL '6'     SECOND(3)            AS mdrReqINTERVAL_3S,    "
+        + "\n  INTERVAL '6'     SECOND(3, 1)         AS mdrReqINTERVAL_3S1,   "
+        + "\n  '' "
+        + "\nFROM INFORMATION_SCHEMA.COLUMNS "
+        + "\nLIMIT 1 " );
+    assertTrue( util.next() );
+    assertTrue("Error creating temporary test-columns view " + VIEW_NAME + ": "
+          + util.getString( 2 ), util.getBoolean( 1 ) );
+
+    // Set up result rows for temporary test view and Hivetest columns:
+
+    mdrOptBOOLEAN        = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptBOOLEAN" );
+
+    mdrReqTINYINT        = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqTINYINT" );
+    mdrOptSMALLINT       = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptSMALLINT" );
+    mdrReqINTEGER        = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTEGER" );
+    mdrOptBIGINT         = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptBIGINT" );
+
+    mdrOptREAL           = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptREAL" );
+    mdrOptFLOAT          = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptFLOAT" );
+    mdrReqDOUBLE         = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqDOUBLE" );
+
+    mdrReqDECIMAL_5_3    = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqDECIMAL_5_3" );
+
+    mdrReqVARCHAR_10     = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqVARCHAR_10" );
+    mdrOptVARCHAR        = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptVARCHAR" );
+    mdrReqCHAR_5         = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqCHAR_5" );
+    mdrOptVARBINARY_16   = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptVARBINARY_16" );
+    mdrOptBINARY_1048576 = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptBINARY_1048576" );
+
+    mdrReqDATE           = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqDATE" );
+    mdrReqTIME           = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqTIME" );
+    mdrOptTIME_7         = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptTIME_7" );
+    mdrOptTIMESTAMP      = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptTIMESTAMP" );
+
+    mdrReqINTERVAL_Y     = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_Y" );
+    mdrReqINTERVAL_3Y_Mo = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_3Y_Mo" );
+    mdrReqINTERVAL_Mo    = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_Mo" );
+    mdrReqINTERVAL_D     = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_D" );
+    mdrReqINTERVAL_4D_H  = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_4D_H" );
+    mdrReqINTERVAL_3D_Mi = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_3D_Mi" );
+    mdrReqINTERVAL_2D_S5 = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_2D_S5" );
+    mdrReqINTERVAL_H     = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_H" );
+    mdrReqINTERVAL_1H_Mi = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_1H_Mi" );
+    mdrReqINTERVAL_3H_S1 = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_3H_S1" );
+    mdrReqINTERVAL_Mi    = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_Mi" );
+    mdrReqINTERVAL_5Mi_S = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_5Mi_S" );
+    mdrReqINTERVAL_S     = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_S" );
+    mdrReqINTERVAL_3S    = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_3S" );
+    mdrReqINTERVAL_3S1   = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTERVAL_3S1" );
+
+    /* TODO(DRILL-3253)(start): Update this once we have test plugin supporting all needed types.
+    mdrReqARRAY   = setUpRow( "hive_test.default", "infoschematest", "listtype" );
+    mdrReqMAP     = setUpRow( "hive_test.default", "infoschematest", "maptype" );
+    mdrUnkSTRUCT = setUpRow( "hive_test.default", "infoschematest", "structtype" );
+    mdrUnkUnion  = setUpRow( "hive_test.default", "infoschematest", "uniontypetype" );
+    TODO(DRILL-3253)(end) */
+
+    // Set up result set's metadata:
+
+    // Get all columns for more diversity of values (e.g., nulls and non-nulls),
+    // in case that affects metadata (e.g., nullability) (in future).
+    final Statement stmt2 = connection.createStatement();
+    final ResultSet allColumns =
+            stmt2.executeQuery( "SELECT * FROM INFORMATION_SCHEMA.COLUMNS " );
+    rowsMetadata = allColumns.getMetaData();
+  }
+
+  @AfterClass
+  public static void tearDownConnection() throws SQLException {
+    final ResultSet util =
+        connection.createStatement().executeQuery( "DROP VIEW " + VIEW_NAME + "" );
+    assertTrue( util.next() );
+    assertTrue("Error dropping temporary test-columns view " + VIEW_NAME + ": "
+         + util.getString( 2 ), util.getBoolean( 1 ) );
+    connection.close();
+  }
+
+
+  private Integer getIntOrNull( ResultSet row, String columnName ) throws SQLException {
+    final int value = row.getInt( columnName );
+    return row.wasNull() ? null : new Integer( value );
+  }
+
+
+  //////////////////////////////////////////////////////////////////////
+  // Tests:
+
+  // INFORMATION_SCHEMA.COLUMNS column positions:
+  //
+  // 1. TABLE_CATALOG
+  // 2. TABLE_SCHEMA
+  // 3. TABLE_NAME
+  // 4. COLUMN_NAME
+  // 5. ORDINAL_POSITION
+  // 6. COLUMN_DEFAULT
+  // 7. IS_NULLABLE
+  // 8. DATA_TYPE
+  // 9. CHARACTER_MAXIMUM_LENGTH
+  // 10. CHARACTER_OCTET_LENGTH
+  // 11. NUMERIC_PRECISION
+  // 12. NUMERIC_PRECISION_RADIX
+  // 13. NUMERIC_SCALE
+  // 14. DATETIME_PRECISION
+  // 15. INTERVAL_TYPE
+  // 16. INTERVAL_PRECISION
+  // 17. CHARACTER_SET_CATALOG
+  // 18. CHARACTER_SET_SCHEMA
+  // 19. CHARACTER_SET_NAME
+  // 20. COLLATION_CATALOG
+  // 21. COLLATION_SCHEMA
+  // 22. COLLATION_NAME
+  // 23. DOMAIN_CATALOG
+  // 24. DOMAIN_SCHEMA
+  // 25. DOMAIN_NAME
+  // 26. UDT_CATALOG
+  // 27. UDT_SCHEMA
+  // 28. UDT_NAME
+  // 29. SCOPE_CATALOG
+  // 30. SCOPE_SCHEMA
+  // 31. SCOPE_NAME
+  // 32. MAXIMUM_CARDINALITY
+  // 33. DTD_IDENTIFIER
+  // 34. IS_SELF_REFERENCING
+  // 35. IS_IDENTITY
+  // 36. IDENTITY_GENERATION
+  // 37. IDENTITY_START
+  // 38. IDENTITY_INCREMENT
+  // 39. IDENTITY_MAXIMUM
+  // 40. IDENTITY_MINIMUM
+  // 41. IDENTITY_CYCLE
+  // 42. IS_GENERATED
+  // 43. GENERATION_EXPRESSION
+  // 44. IS_SYSTEM_TIME_PERIOD_START
+  // 45. IS_SYSTEM_TIME_PERIOD_END
+  // 46. SYSTEM_TIME_PERIOD_TIMESTAMP_GENERATION
+  // 47. IS_UPDATABLE
+  // 48. DECLARED_DATA_TYPE
+  // 49. DECLARED_NUMERIC_PRECISION
+  // 50. DECLARED_NUMERIC_SCALE
+
+
+  ////////////////////////////////////////////////////////////
+  // Number of columns.
+
+  @Ignore( "unless and until all COLUMNS columns are present" )
+  @Test
+  public void testMetadataHasRightNumberOfColumns() throws SQLException {
+    // Is this check valid?  (Are extra columns allowed?)
+    assertThat( "column count", rowsMetadata.getColumnCount(), equalTo( 50 ) );
+  }
+
+  @Test
+  public void testMetadataHasInterimNumberOfColumns() throws SQLException {
+    assertThat( "column count", rowsMetadata.getColumnCount(), equalTo( 16 ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #1: TABLE_CATALOG:
+  // - SQL:
+  // - Drill:  Always "DRILL".
+  // - (Meta): VARCHAR; Non-nullable(?);
+
+  @Test
+  public void test_TABLE_CATALOG_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 1 ), equalTo( "TABLE_CATALOG" ) );
+  }
+
+  @Test
+  public void test_TABLE_CATALOG_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( mdrOptBOOLEAN.getString( "TABLE_CATALOG" ), equalTo( "DRILL" ) );
+  }
+
+  // Not bothering with other test columns for TABLE_CAT.
+
+  @Test
+  public void test_TABLE_CATALOG_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 1 ), equalTo( "TABLE_CATALOG" ) );
+  }
+
+  @Test
+  public void test_TABLE_CATALOG_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 1 ), equalTo( "VARCHAR" ) );
+  }
+
+  @Test
+  public void test_TABLE_CATALOG_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 1 ), equalTo( Types.VARCHAR ) );
+  }
+
+  @Ignore( "until resolved:  any requirement on nullability (DRILL-2420?)" )
+  @Test
+  public void test_TABLE_CATALOG_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 1 ), equalTo( columnNoNulls ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #2: TABLE_SCHEMA:
+  // - SQL:
+  // - Drill:
+  // - (Meta): VARCHAR; Non-nullable(?);
+
+  @Test
+  public void test_TABLE_SCHEMA_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 2 ), equalTo( "TABLE_SCHEMA" ) );
+  }
+
+  @Test
+  public void test_TABLE_SCHEMA_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( mdrOptBOOLEAN.getString( "TABLE_SCHEMA" ), equalTo( VIEW_SCHEMA ) );
+  }
+
+  // Not bothering with other _local_view_ test columns for TABLE_SCHEM.
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_TABLE_SCHEMA_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( mdrReqARRAY.getString( "TABLE_SCHEMA" ), equalTo( "hive_test.default" ) );
+  }
+
+  // Not bothering with other Hive test columns for TABLE_SCHEM.
+
+  @Test
+  public void test_TABLE_SCHEMA_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 2 ), equalTo( "TABLE_SCHEMA" ) );
+  }
+
+  @Test
+  public void test_TABLE_SCHEMA_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 2 ), equalTo( "VARCHAR" ) );
+  }
+
+  @Test
+  public void test_TABLE_SCHEMA_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 2 ), equalTo( Types.VARCHAR ) );
+  }
+
+  @Ignore( "until resolved:  any requirement on nullability (DRILL-2420?)" )
+  @Test
+  public void test_TABLE_SCHEMA_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 2 ), equalTo( columnNoNulls ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #3: TABLE_NAME:
+  // - SQL:
+  // - Drill:
+  // - (Meta): VARCHAR; Non-nullable(?);
+
+  @Test
+  public void test_TABLE_NAME_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 3 ), equalTo( "TABLE_NAME" ) );
+  }
+
+  @Test
+  public void test_TABLE_NAME_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( mdrOptBOOLEAN.getString( "TABLE_NAME" ), equalTo( VIEW_NAME ) );
+  }
+
+  // Not bothering with other _local_view_ test columns for TABLE_NAME.
+
+  @Test
+  public void test_TABLE_NAME_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 3 ), equalTo( "TABLE_NAME" ) );
+  }
+
+  @Test
+  public void test_TABLE_NAME_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 3 ), equalTo( "VARCHAR" ) );
+  }
+
+  @Test
+  public void test_TABLE_NAME_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 3 ), equalTo( Types.VARCHAR ) );
+  }
+
+  @Ignore( "until resolved:  any requirement on nullability (DRILL-2420?)" )
+  @Test
+  public void test_TABLE_NAME_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 3 ), equalTo( columnNoNulls ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #4: COLUMN_NAME:
+  // - SQL:
+  // - Drill:
+  // - (Meta): VARCHAR; Non-nullable(?);
+
+  @Test
+  public void test_COLUMN_NAME_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 4 ), equalTo( "COLUMN_NAME" ) );
+  }
+
+  @Test
+  public void test_COLUMN_NAME_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( mdrOptBOOLEAN.getString( "COLUMN_NAME" ), equalTo( "mdrOptBOOLEAN" ) );
+  }
+
+  // Not bothering with other _local_view_ test columns for TABLE_SCHEM.
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_COLUMN_NAME_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( mdrReqARRAY.getString( "COLUMN_NAME" ), equalTo( "listtype" ) );
+  }
+
+  // Not bothering with other Hive test columns for TABLE_SCHEM.
+
+  @Test
+  public void test_COLUMN_NAME_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 4 ), equalTo( "COLUMN_NAME" ) );
+  }
+
+  @Test
+  public void test_COLUMN_NAME_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 4 ), equalTo( "VARCHAR" ) );
+  }
+
+  @Test
+  public void test_COLUMN_NAME_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 4 ), equalTo( Types.VARCHAR ) );
+  }
+
+  @Ignore( "until resolved:  any requirement on nullability (DRILL-2420?)" )
+  @Test
+  public void test_COLUMN_NAME_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 4 ), equalTo( columnNoNulls ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #5: ORDINAL_POSITION:
+  // - SQL:
+  // - Drill:
+  // - (Meta):  INTEGER NOT NULL
+
+  @Test
+  public void test_ORDINAL_POSITION_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 5 ), equalTo( "ORDINAL_POSITION" ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( mdrOptBOOLEAN.getInt( "ORDINAL_POSITION" ), equalTo( 1 ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( mdrReqTINYINT.getInt( "ORDINAL_POSITION" ), equalTo( 2 ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( mdrOptSMALLINT.getInt( "ORDINAL_POSITION" ), equalTo( 3 ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( mdrReqINTEGER.getInt( "ORDINAL_POSITION" ), equalTo( 4 ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( mdrOptBIGINT.getInt( "ORDINAL_POSITION" ), equalTo( 5 ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( mdrOptREAL.getInt( "ORDINAL_POSITION" ), equalTo( 6 ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( mdrOptFLOAT.getInt( "ORDINAL_POSITION" ), equalTo( 7 ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( mdrReqDOUBLE.getInt( "ORDINAL_POSITION" ), equalTo( 8 ) );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_ORDINAL_POSITION_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( mdrReqARRAY.getInt( "ORDINAL_POSITION" ), equalTo( 14 ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 5 ), equalTo( "ORDINAL_POSITION" ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 5 ), equalTo( "INTEGER" ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 5 ), equalTo( Types.INTEGER ) );
+  }
+
+  @Test
+  public void test_ORDINAL_POSITION_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 5 ), equalTo( columnNoNulls ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #6: COLUMN_DEFAULT:
+  // - SQL:
+  // - Drill:
+  // - (Meta): VARCHAR; Nullable;
+
+  @Test
+  public void test_COLUMN_DEFAULT_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 6 ), equalTo( "COLUMN_DEFAULT" ) );
+  }
+
+  @Test
+  public void test_COLUMN_DEFAULT_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( mdrOptBOOLEAN.getString( "COLUMN_DEFAULT" ), nullValue() );
+  }
+
+  // Not bothering with other _local_view_ test columns for COLUMN_DEFAULT.
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_COLUMN_DEFAULT_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( mdrReqARRAY.getString( "COLUMN_DEFAULT" ), nullValue() );
+  }
+
+  // Not bothering with other Hive test columns for TABLE_SCHEM.
+
+  @Test
+  public void test_COLUMN_DEFAULT_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 6 ), equalTo( "COLUMN_DEFAULT" ) );
+  }
+
+  @Test
+  public void test_COLUMN_DEFAULT_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 6 ), equalTo( "VARCHAR" ) );
+  }
+
+  @Test
+  public void test_COLUMN_DEFAULT_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 6 ), equalTo( Types.VARCHAR ) );
+  }
+
+  @Test
+  public void test_COLUMN_DEFAULT_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 6 ), equalTo( columnNullable ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #7: IS_NULLABLE:
+  // - SQL:
+  //   YES  The column is possibly nullable.
+  //   NO   The column is known not nullable.
+  // - Drill:
+  // - (Meta): VARCHAR; Non-nullable(?).
+
+  @Test
+  public void test_IS_NULLABLE_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 7 ), equalTo( "IS_NULLABLE" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptBOOLEAN.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqTINYINT.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptSMALLINT.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqINTEGER.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptBIGINT.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptREAL.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptFLOAT.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqDOUBLE.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqDECIMAL_5_3() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqDECIMAL_5_3.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqVARCHAR_10() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqVARCHAR_10.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptVARCHAR() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptVARCHAR.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqCHAR_5() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqCHAR_5.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptVARBINARY_16() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptVARBINARY_16.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptBINARY_1048576() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptBINARY_1048576.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqDATE() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqDATE.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqTIME() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqTIME.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptTIME_7() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptTIME_7.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrOptTIMESTAMP() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrOptTIMESTAMP.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqINTERVAL_Y() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqINTERVAL_Y.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_mdrReqINTERVAL_H_S3() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqINTERVAL_3H_S1.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_IS_NULLABLE_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqARRAY.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_IS_NULLABLE_hasRightValue_tbdMAP() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrReqMAP.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_tbdSTRUCT() throws SQLException {
+    assertThat( mdrUnkSTRUCT.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+    // To-do:  Determine which.
+    assertThat( mdrUnkSTRUCT.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Test
+  public void test_IS_NULLABLE_hasRightValue_tbdUnion() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrUnkUnion.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
+    // To-do:  Determine which.
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                mdrUnkUnion.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 7 ), equalTo( "IS_NULLABLE" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 7 ), equalTo( "VARCHAR" ) );
+  }
+
+  @Test
+  public void test_IS_NULLABLE_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 7 ), equalTo( Types.VARCHAR ) );
+  }
+
+  @Ignore( "until resolved:  any requirement on nullability (DRILL-2420?)" )
+  @Test
+  public void test_IS_NULLABLE_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 7 ), equalTo( columnNoNulls ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #8: DATA_TYPE:
+  // - SQL:
+  // - Drill:
+  // - (Meta): VARCHAR; Non-nullable(?);
+
+  @Test
+  public void test_DATA_TYPE_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 8 ), equalTo( "DATA_TYPE" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( mdrOptBOOLEAN.getString( "DATA_TYPE" ), equalTo( "BOOLEAN" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( mdrReqTINYINT.getString( "DATA_TYPE" ), equalTo( "TINYINT" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( mdrOptSMALLINT.getString( "DATA_TYPE" ), equalTo( "SMALLINT" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( mdrReqINTEGER.getString( "DATA_TYPE" ), equalTo( "INTEGER" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( mdrOptBIGINT.getString( "DATA_TYPE" ), equalTo( "BIGINT" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( mdrOptREAL.getString( "DATA_TYPE" ), equalTo( "REAL" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( mdrOptFLOAT.getString( "DATA_TYPE" ), equalTo( "FLOAT" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( mdrReqDOUBLE.getString( "DATA_TYPE" ), equalTo( "DOUBLE" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqDECIMAL_5_3() throws SQLException {
+    assertThat( mdrReqDECIMAL_5_3.getString( "DATA_TYPE" ), equalTo( "DECIMAL" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqVARCHAR_10() throws SQLException {
+    assertThat( mdrReqVARCHAR_10.getString( "DATA_TYPE" ), equalTo( "CHARACTER VARYING" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptVARCHAR() throws SQLException {
+    assertThat( mdrOptVARCHAR.getString( "DATA_TYPE" ), equalTo( "CHARACTER VARYING" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqCHAR_5() throws SQLException {
+    assertThat( mdrReqCHAR_5.getString( "DATA_TYPE" ), equalTo( "CHARACTER" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptVARBINARY_16() throws SQLException {
+    assertThat( mdrOptVARBINARY_16.getString( "DATA_TYPE" ), equalTo( "BINARY VARYING" ) );
+  }
+
+  @Ignore( "until BINARY is actually BINARY and not VARBINARY (DRILL-xxxx)" )
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptBINARY_1048576() throws SQLException {
+    assertThat( mdrOptBINARY_1048576.getString( "DATA_TYPE" ), equalTo( "BINARY VARYING" ) ); // ?? current
+    assertThat( mdrOptBINARY_1048576.getString( "DATA_TYPE" ), equalTo( "BINARY" ) );  // ?? should be
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqDATE() throws SQLException {
+    assertThat( mdrReqDATE.getString( "DATA_TYPE" ), equalTo( "DATE" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqTIME() throws SQLException {
+    // (TIME defaults to TIME WITHOUT TIME ZONE, which uses "TIME" here.)
+    assertThat( mdrReqTIME.getString( "DATA_TYPE" ), equalTo( "TIME" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptTIME_7() throws SQLException {
+    // (TIME defaults to TIME WITHOUT TIME ZONE, which uses "TIME" here.)
+    assertThat( mdrOptTIME_7.getString( "DATA_TYPE" ), equalTo( "TIME" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrOptTIMESTAMP() throws SQLException {
+    assertThat( mdrOptTIMESTAMP.getString( "DATA_TYPE" ), equalTo( "TIMESTAMP" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqINTERVAL_Y() throws SQLException {
+    assertThat( mdrReqINTERVAL_Y.getString( "DATA_TYPE" ), equalTo( "INTERVAL" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightValue_mdrReqINTERVAL_H_S3() throws SQLException {
+    assertThat( mdrReqINTERVAL_3H_S1.getString( "DATA_TYPE" ), equalTo( "INTERVAL" ) );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_DATA_TYPE_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( mdrReqARRAY.getString( "DATA_TYPE" ), equalTo( "ARRAY" ) );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_DATA_TYPE_hasRightValue_tbdMAP() throws SQLException {
+    assertThat( mdrReqMAP.getString( "DATA_TYPE" ), equalTo( "MAP" ) );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_DATA_TYPE_hasRightValue_tbdSTRUCT() throws SQLException {
+    assertThat( mdrUnkSTRUCT.getString( "DATA_TYPE" ), equalTo( "STRUCT" ) );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_DATA_TYPE_hasRightValue_tbdUnion() throws SQLException {
+    assertThat( mdrUnkUnion.getString( "DATA_TYPE" ), equalTo( "OTHER" ) );
+    fail( "Expected value is not resolved yet." );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 8 ), equalTo( "DATA_TYPE" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 8 ), equalTo( "VARCHAR" ) );
+  }
+
+  @Test
+  public void test_DATA_TYPE_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 8 ), equalTo( Types.VARCHAR ) );
+  }
+
+  @Ignore( "until resolved:  any requirement on nullability (DRILL-2420?)" )
+  @Test
+  public void test_DATA_TYPE_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 8 ), equalTo( columnNoNulls ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #9: CHARACTER_MAXIMUM_LENGTH:
+  // - SQL:
+  // - Drill:
+  // - (Meta): INTEGER; Nullable;
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 9 ), equalTo( "CHARACTER_MAXIMUM_LENGTH" ) );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBOOLEAN, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTINYINT, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptSMALLINT, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTEGER, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBIGINT, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( getIntOrNull( mdrOptREAL, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptFLOAT, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDOUBLE, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqDECIMAL_5_3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDECIMAL_5_3, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqVARCHAR_10() throws SQLException {
+    assertThat( getIntOrNull( mdrReqVARCHAR_10, "CHARACTER_MAXIMUM_LENGTH" ), equalTo( 10 ) );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptVARCHAR() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARCHAR, "CHARACTER_MAXIMUM_LENGTH" ), equalTo( 1 ) );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqCHAR_5() throws SQLException {
+    assertThat( getIntOrNull( mdrReqCHAR_5, "CHARACTER_MAXIMUM_LENGTH" ), equalTo( 5 ) );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptVARBINARY_16() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARBINARY_16, "CHARACTER_MAXIMUM_LENGTH" ), equalTo( 16 ) );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptBINARY_1048576() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBINARY_1048576, "CHARACTER_MAXIMUM_LENGTH" ), equalTo( 1048576 ) );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqDATE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDATE, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqTIME() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTIME, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptTIME_7() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIME_7, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptTIMESTAMP() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIMESTAMP, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqINTERVAL_Y() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_Y, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqINTERVAL_H_S3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_3H_S1, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( getIntOrNull( mdrReqARRAY, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_tbdMAP() throws SQLException {
+    assertThat( getIntOrNull( mdrReqMAP, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_tbdSTRUCT() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkSTRUCT, "CHARACTER_MAXIMUM_LENGTH"), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_tbdUnion() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkUnion, "CHARACTER_MAXIMUM_LENGTH"), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 9 ), equalTo( "CHARACTER_MAXIMUM_LENGTH" ) );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 9 ), equalTo( "INTEGER" ) );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 9 ), equalTo( Types.INTEGER ) );
+  }
+
+  @Test
+  public void test_CHARACTER_MAXIMUM_LENGTH_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 9 ), equalTo( columnNullable ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #10: CHARACTER_OCTET_LENGTH:
+  // - SQL:
+  // - Drill:
+  // - (Meta): INTEGER; Nullable;
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 10 ), equalTo( "CHARACTER_OCTET_LENGTH" ) );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBOOLEAN, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTINYINT, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptREAL, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptSMALLINT, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTEGER, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( getIntOrNull( mdrOptREAL, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptFLOAT, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDOUBLE, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqDECIMAL_5_3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDECIMAL_5_3, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqVARCHAR_10() throws SQLException {
+    assertThat( getIntOrNull( mdrReqVARCHAR_10, "CHARACTER_OCTET_LENGTH" ),
+                equalTo( 10   /* chars. */
+                         * 4  /* max. UTF-8 bytes per char. */ ) );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptVARCHAR() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARCHAR, "CHARACTER_OCTET_LENGTH" ),
+                equalTo( 1    /* chars. (default of 1) */
+                         * 4  /* max. UTF-8 bytes per char. */ ) );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqCHAR_5() throws SQLException {
+    assertThat( getIntOrNull( mdrReqCHAR_5, "CHARACTER_OCTET_LENGTH" ),
+                equalTo( 5    /* chars. */
+                         * 4  /* max. UTF-8 bytes per char. */ ) );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptVARBINARY_16() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARBINARY_16, "CHARACTER_OCTET_LENGTH" ), equalTo( 16 ) );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptBINARY_1048576() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBINARY_1048576, "CHARACTER_OCTET_LENGTH" ), equalTo( 1048576 ));
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqDATE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDATE, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqTIME() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTIME, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptTIME_7() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIME_7, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptTIMESTAMP() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIMESTAMP, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqINTERVAL_Y() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_Y, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqINTERVAL_H_S3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_3H_S1, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( getIntOrNull( mdrReqARRAY, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_tbdMAP() throws SQLException {
+    assertThat( getIntOrNull( mdrReqMAP, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_tbdSTRUCT() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkSTRUCT, "CHARACTER_OCTET_LENGTH" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_CHARACTER_OCTET_LENGTH_hasRightValue_tbdUnion() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkUnion, "CHARACTER_OCTET_LENGTH"), nullValue() );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 10 ), equalTo( "CHARACTER_OCTET_LENGTH" ) );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 10 ), equalTo( "INTEGER" ) );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 10 ), equalTo( Types.INTEGER ) );
+  }
+
+  @Test
+  public void test_CHARACTER_OCTET_LENGTH_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 10 ), equalTo( columnNullable ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #11: NUMERIC_PRECISION:
+  // - SQL:
+  // - Drill:
+  // - (Meta): INTEGER; Nullable;
+
+  @Test
+  public void test_NUMERIC_PRECISION_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 11 ), equalTo( "NUMERIC_PRECISION" ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBOOLEAN, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTINYINT, "NUMERIC_PRECISION" ), equalTo( 8 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptSMALLINT, "NUMERIC_PRECISION" ), equalTo( 16 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTEGER, "NUMERIC_PRECISION" ), equalTo( 32 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBIGINT, "NUMERIC_PRECISION" ), equalTo( 64 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( getIntOrNull( mdrOptREAL, "NUMERIC_PRECISION" ), equalTo( 24 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptFLOAT, "NUMERIC_PRECISION" ), equalTo( 24 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDOUBLE, "NUMERIC_PRECISION" ), equalTo( 53 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqDECIMAL_5_3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDECIMAL_5_3, "NUMERIC_PRECISION" ), equalTo( 5 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqVARCHAR_10() throws SQLException {
+    assertThat( getIntOrNull( mdrReqVARCHAR_10, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptVARCHAR() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARCHAR, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqCHAR_5() throws SQLException {
+    assertThat( getIntOrNull( mdrReqCHAR_5, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptVARBINARY_16() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARBINARY_16, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptBINARY_1048576() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBINARY_1048576, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqDATE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDATE, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqTIME() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTIME, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptTIME_7() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIME_7, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrOptTIMESTAMP() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIMESTAMP, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqINTERVAL_Y() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_Y, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightValue_mdrReqINTERVAL_H_S3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_3H_S1, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_PRECISION_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( getIntOrNull( mdrReqARRAY, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_PRECISION_hasRightValue_tbdMAP() throws SQLException {
+    assertThat( getIntOrNull( mdrReqMAP, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_PRECISION_hasRightValue_tbdSTRUCT() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkSTRUCT, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_PRECISION_hasRightValue_tbdUnion() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkUnion, "NUMERIC_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 11 ), equalTo( "NUMERIC_PRECISION" ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 11 ), equalTo( "INTEGER" ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 11 ), equalTo( Types.INTEGER ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 11 ), equalTo( columnNullable ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #12: NUMERIC_PRECISION_RADIX:
+  // - SQL:
+  // - Drill:
+  // - (Meta): INTEGER; Nullable;
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 12 ), equalTo( "NUMERIC_PRECISION_RADIX" ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBOOLEAN, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTINYINT, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptSMALLINT, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTEGER, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBIGINT, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( getIntOrNull( mdrOptREAL, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptFLOAT, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDOUBLE, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqDECIMAL_5_3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDECIMAL_5_3, "NUMERIC_PRECISION_RADIX" ), equalTo( 10 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqVARCHAR_10() throws SQLException {
+    assertThat( getIntOrNull( mdrReqVARCHAR_10, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptVARCHAR() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARCHAR, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqCHAR_5() throws SQLException {
+    assertThat( getIntOrNull( mdrReqCHAR_5, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptVARBINARY_16() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARBINARY_16, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptBINARY_1048576() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBINARY_1048576, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqDATE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDATE, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqTIME() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTIME, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptTIME_7() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIME_7, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptTIMESTAMP() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIMESTAMP, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqINTERVAL_Y() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_Y, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqINTERVAL_H_S3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_3H_S1, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( getIntOrNull( mdrReqARRAY, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_tbdMAP() throws SQLException {
+    assertThat( getIntOrNull( mdrReqMAP, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_tbdSTRUCT() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkSTRUCT, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_PRECISION_RADIX_hasRightValue_tbdUnion() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkUnion, "NUMERIC_PRECISION_RADIX" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 12 ), equalTo( "NUMERIC_PRECISION_RADIX" ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 12 ), equalTo( "INTEGER" ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 12 ), equalTo( Types.INTEGER ) );
+  }
+
+  @Test
+  public void test_NUMERIC_PRECISION_RADIX_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 12 ), equalTo( columnNullable ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #13: NUMERIC_SCALE:
+  // - SQL:
+  // - Drill:
+  // - (Meta):  INTEGER; Nullable;
+
+  @Test
+  public void test_NUMERIC_SCALE_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 13 ), equalTo( "NUMERIC_SCALE" ) );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBOOLEAN, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTINYINT, "NUMERIC_SCALE" ), equalTo( 0 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptSMALLINT, "NUMERIC_SCALE" ), equalTo( 0 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTEGER, "NUMERIC_SCALE" ), equalTo( 0 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBIGINT, "NUMERIC_SCALE" ), equalTo( 0 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( getIntOrNull( mdrOptREAL, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptFLOAT, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDOUBLE, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqDECIMAL_5_3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDECIMAL_5_3, "NUMERIC_SCALE" ), equalTo( 3 ) );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqVARCHAR_10() throws SQLException {
+    assertThat( getIntOrNull( mdrReqVARCHAR_10, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptVARCHAR() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARCHAR, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqCHAR_5() throws SQLException {
+    assertThat( getIntOrNull( mdrReqCHAR_5, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptVARBINARY_16() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARBINARY_16, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptBINARY_1048576() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBINARY_1048576, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqDATE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDATE, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqTIME() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTIME, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptTIME_7() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIME_7, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrOptTIMESTAMP() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIMESTAMP, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqINTERVAL_Y() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_Y, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightValue_mdrReqINTERVAL_H_S3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_3H_S1, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_SCALE_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( getIntOrNull( mdrReqARRAY, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_SCALE_hasRightValue_tbdMAP() throws SQLException {
+    assertThat( getIntOrNull( mdrReqMAP, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_SCALE_hasRightValue_tbdSTRUCT() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkSTRUCT, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_NUMERIC_SCALE_hasRightValue_tbdUnion() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkUnion, "NUMERIC_SCALE" ), nullValue() );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 13 ), equalTo( "NUMERIC_SCALE" ) );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 13 ), equalTo( "INTEGER" ) );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 13 ), equalTo( Types.INTEGER ) );
+  }
+
+  @Test
+  public void test_NUMERIC_SCALE_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 13 ), equalTo( columnNullable ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #14: DATETIME_PRECISION:
+  // - SQL:
+  // - Drill:
+  // - (Meta): INTEGER; Nullable;
+
+  @Test
+  public void test_DATETIME_PRECISION_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 14 ), equalTo( "DATETIME_PRECISION" ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBOOLEAN, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( getIntOrNull( mdrReqTINYINT, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptSMALLINT, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTEGER, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBIGINT, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( getIntOrNull( mdrOptREAL, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( getIntOrNull( mdrOptFLOAT, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDOUBLE, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqDECIMAL_5_3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqDECIMAL_5_3, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqVARCHAR_10() throws SQLException {
+    assertThat( getIntOrNull( mdrReqVARCHAR_10, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptVARCHAR() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARCHAR, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqCHAR_5() throws SQLException {
+    assertThat( getIntOrNull( mdrReqCHAR_5, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptVARBINARY_16() throws SQLException {
+    assertThat( getIntOrNull( mdrOptVARBINARY_16, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptBINARY_1048576() throws SQLException {
+    assertThat( getIntOrNull( mdrOptBINARY_1048576, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqDATE() throws SQLException {
+    // Zero because DATE doesn't (seem to) have a datetime precision, but its
+    // DATETIME_PRECISION value must not be null.
+    assertThat( getIntOrNull( mdrReqDATE, "DATETIME_PRECISION" ), equalTo( 0 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqTIME() throws SQLException {
+    // Zero is default datetime precision for TIME.
+    assertThat( getIntOrNull( mdrReqTIME, "DATETIME_PRECISION" ), equalTo( 0 ) );
+  }
+
+  @Ignore( "until datetime precision is implemented" )
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptTIME_7() throws SQLException {
+    assertThat( getIntOrNull( mdrOptTIME_7, "DATETIME_PRECISION" ), equalTo( 7 ) );
+  }
+
+  @Test
+  @Ignore( "until datetime precision is implemented" )
+  public void test_DATETIME_PRECISION_hasRightValue_mdrOptTIMESTAMP() throws SQLException {
+    // 6 is default datetime precision for TIMESTAMP.
+    assertThat( getIntOrNull( mdrOptTIMESTAMP, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_Y() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_Y, "DATETIME_PRECISION" ), equalTo( 0 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_3Y_Mo() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_3Y_Mo, "DATETIME_PRECISION" ), equalTo( 0 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_Mo() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_Mo, "DATETIME_PRECISION" ), equalTo( 0 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_D() throws SQLException {
+    // 6 seems to be Drill's (Calcite's) choice (to use default value for the
+    // fractional seconds precision for when SECOND _is_ present) since the SQL
+    // spec. (ISO/IEC 9075-2:2011(E) 10.1 <interval qualifier>) doesn't seem to
+    // specify the fractional seconds precision when SECOND is _not_ present.
+    assertThat( getIntOrNull( mdrReqINTERVAL_D, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_4D_H() throws SQLException {
+    // 6 seems to be Drill's (Calcite's) choice (to use default value for the
+    // fractional seconds precision for when SECOND _is_ present) since the SQL
+    // spec. (ISO/IEC 9075-2:2011(E) 10.1 <interval qualifier>) doesn't seem to
+    // specify the fractional seconds precision when SECOND is _not_ present.
+    assertThat( getIntOrNull( mdrReqINTERVAL_4D_H, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_3D_Mi() throws SQLException {
+    // 6 seems to be Drill's (Calcite's) choice (to use default value for the
+    // fractional seconds precision for when SECOND _is_ present) since the SQL
+    // spec. (ISO/IEC 9075-2:2011(E) 10.1 <interval qualifier>) doesn't seem to
+    // specify the fractional seconds precision when SECOND is _not_ present.
+    assertThat( getIntOrNull( mdrReqINTERVAL_3D_Mi, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Ignore( "until fixed:  fractional secs. prec. gets wrong value (DRILL-3244)" )
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_2D_S5() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_2D_S5, "DATETIME_PRECISION" ), equalTo( 5 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasINTERIMValue_mdrReqINTERVAL_2D_S5() throws SQLException {
+    assertThat( "When DRILL-3244 fixed, un-ignore above method and purge this.",
+                getIntOrNull( mdrReqINTERVAL_2D_S5, "DATETIME_PRECISION" ), equalTo( 2 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_H() throws SQLException {
+    // 6 seems to be Drill's (Calcite's) choice (to use default value for the
+    // fractional seconds precision for when SECOND _is_ present) since the SQL
+    // spec. (ISO/IEC 9075-2:2011(E) 10.1 <interval qualifier>) doesn't seem to
+    // specify the fractional seconds precision when SECOND is _not_ present.
+    assertThat( getIntOrNull( mdrReqINTERVAL_H, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_1H_Mi() throws SQLException {
+    // 6 seems to be Drill's (Calcite's) choice (to use default value for the
+    // fractional seconds precision for when SECOND _is_ present) since the SQL
+    // spec. (ISO/IEC 9075-2:2011(E) 10.1 <interval qualifier>) doesn't seem to
+    // specify the fractional seconds precision when SECOND is _not_ present.
+    assertThat( getIntOrNull( mdrReqINTERVAL_1H_Mi, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Ignore( "until fixed:  fractional secs. prec. gets start unit prec. (DRILL-3244) " )
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_H_S3() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_3H_S1, "DATETIME_PRECISION" ), equalTo( 1 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasINTERIMValue_mdrReqINTERVAL_H_S3() throws SQLException {
+    assertThat( "When DRILL-3244 fixed, un-ignore above method and purge this.",
+                getIntOrNull( mdrReqINTERVAL_3H_S1, "DATETIME_PRECISION" ), equalTo( 3 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_Mi() throws SQLException {
+    // 6 seems to be Drill's (Calcite's) choice (to use default value for the
+    // fractional seconds precision for when SECOND _is_ present) since the SQL
+    // spec. (ISO/IEC 9075-2:2011(E) 10.1 <interval qualifier>) doesn't seem to
+    // specify the fractional seconds precision when SECOND is _not_ present.
+    assertThat( getIntOrNull( mdrReqINTERVAL_Mi, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_5Mi_S() throws SQLException {
+    // 6 is default fractional seconds precision when SECOND field is present.
+    assertThat( getIntOrNull( mdrReqINTERVAL_5Mi_S, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_S() throws SQLException {
+    // 6 is default for interval fraction seconds precision.
+    assertThat( getIntOrNull( mdrReqINTERVAL_S, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_3S() throws SQLException {
+    // 6 is default fractional seconds precision when SECOND field is present.
+    assertThat( getIntOrNull( mdrReqINTERVAL_3S, "DATETIME_PRECISION" ), equalTo( 6 ) );
+  }
+
+  @Ignore( "until fixed:  fractional secs. prec. gets start unit prec. (DRILL-3244) " )
+  @Test
+  public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_3S1() throws SQLException {
+    assertThat( getIntOrNull( mdrReqINTERVAL_3S1, "DATETIME_PRECISION" ), equalTo( 1 ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasINTERIMValue_mdrReqINTERVAL_3S1() throws SQLException {
+    assertThat( "When DRILL-3244 fixed, un-ignore above method and purge this.",
+                getIntOrNull( mdrReqINTERVAL_3S1, "DATETIME_PRECISION" ), equalTo( 3 ) );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_DATETIME_PRECISION_hasRightValue_tdbARRAY() throws SQLException {
+    assertThat( getIntOrNull( mdrReqARRAY, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_DATETIME_PRECISION_hasRightValue_tbdMAP() throws SQLException {
+    assertThat( getIntOrNull( mdrReqMAP, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_DATETIME_PRECISION_hasRightValue_tbdSTRUCT() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkSTRUCT, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  public void test_DATETIME_PRECISION_hasRightValue_tbdUnion() throws SQLException {
+    assertThat( getIntOrNull( mdrUnkUnion, "DATETIME_PRECISION" ), nullValue() );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasSameNameAndLabel() throws SQLException {
+    assertThat( rowsMetadata.getColumnName( 14 ), equalTo( "DATETIME_PRECISION" ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightTypeString() throws SQLException {
+    assertThat( rowsMetadata.getColumnTypeName( 14 ), equalTo( "INTEGER" ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightTypeCode() throws SQLException {
+    assertThat( rowsMetadata.getColumnType( 14 ), equalTo( Types.INTEGER ) );
+  }
+
+  @Test
+  public void test_DATETIME_PRECISION_hasRightNullability() throws SQLException {
+    assertThat( "ResultSetMetaData.column...Null... nullability code:",
+                rowsMetadata.isNullable( 14 ), equalTo( columnNullable ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // #15: INTERVAL_TYPE:
+  // - SQL:
+  // - Drill:
+  // - (Meta): VARCHAR; Nullable;
+
+  @Test
+  public void test_INTERVAL_TYPE_isAtRightPosition() throws SQLException {
+    assertThat( rowsMetadata.getColumnLabel( 15 ), equalTo( "INTERVAL_TYPE" ) );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrOptBOOLEAN() throws SQLException {
+    assertThat( mdrOptBOOLEAN.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrReqTINYINT() throws SQLException {
+    assertThat( mdrReqTINYINT.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrOptSMALLINT() throws SQLException {
+    assertThat( mdrOptSMALLINT.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrReqINTEGER() throws SQLException {
+    assertThat( mdrReqINTEGER.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrOptBIGINT() throws SQLException {
+    assertThat( mdrOptBIGINT.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrOptREAL() throws SQLException {
+    assertThat( mdrOptREAL.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrOptFLOAT() throws SQLException {
+    assertThat( mdrOptFLOAT.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrReqDOUBLE() throws SQLException {
+    assertThat( mdrReqDOUBLE.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrReqDECIMAL_5_3() throws SQLException {
+    assertThat( mdrReqDECIMAL_5_3.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrReqVARCHAR_10() throws SQLException {
+    assertThat( mdrReqVARCHAR_10.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrOptVARCHAR() throws SQLException {
+    assertThat( mdrOptVARCHAR.getString( "INTERVAL_TYPE" ), nullValue() );
+  }
+
+  @Test
+  public void test_INTERVAL_TYPE_hasRightValue_mdrReqCHAR_5() throws SQL

<TRUNCATED>

Mime
View raw message