drill-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From meh...@apache.org
Subject [1/3] drill git commit: DRILL-3151: Fix many ResultSetMetaData method return values.
Date Fri, 31 Jul 2015 03:16:43 GMT
Repository: drill
Updated Branches:
  refs/heads/master 9932246ce -> 808350824


http://git-wip-us.apache.org/repos/asf/drill/blob/80835082/exec/jdbc/src/test/java/org/apache/drill/jdbc/ResultSetMetaDataTest.java
----------------------------------------------------------------------
diff --git a/exec/jdbc/src/test/java/org/apache/drill/jdbc/ResultSetMetaDataTest.java b/exec/jdbc/src/test/java/org/apache/drill/jdbc/ResultSetMetaDataTest.java
new file mode 100644
index 0000000..ba5435f
--- /dev/null
+++ b/exec/jdbc/src/test/java/org/apache/drill/jdbc/ResultSetMetaDataTest.java
@@ -0,0 +1,1107 @@
+/**
+ * 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;
+
+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.test.JdbcAssert;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.sql.SQLException;
+import java.sql.Types;
+
+
+/**
+ * Test class for Drill's java.sql.ResultSetMetaData implementation.
+ * <p>
+ *   Based on JDBC 4.1 (Java 7).
+ * </p>
+ */
+public class ResultSetMetaDataTest extends JdbcTestBase {
+
+  private static final String VIEW_SCHEMA = "dfs_test.tmp";
+  private static final String VIEW_NAME =
+      ResultSetMetaDataTest.class.getSimpleName() + "_View";
+
+  /** The one shared JDBC connection to Drill. */
+  private static Connection connection;
+
+  // Result set with test columns of various types.  Is positioned at first row
+  // for, and must not be modified by, test methods.
+  private static ResultSet viewRow;
+
+  // Metadata for result set.
+  private static ResultSetMetaData rowMetadata;
+
+  //////////
+  // For columns in temporary test view (types accessible via casting):
+
+  // (Dynamic to make it simpler to add or remove columns.)
+  private static int columnCount;
+
+  private static int ordOptBOOLEAN;
+  private static int ordReqBOOLEAN;
+
+  private static int ordReqSMALLINT;
+  private static int ordReqINTEGER;
+  private static int ordReqBIGINT;
+
+  private static int ordReqREAL;
+  private static int ordReqFLOAT;
+  private static int ordReqDOUBLE;
+
+  private static int ordReqDECIMAL_5_3;
+  // No NUMERIC while Drill just maps it to DECIMAL.
+
+  private static int ordReqVARCHAR_10;
+  private static int ordOptVARCHAR;
+  private static int ordReqCHAR_5;
+  // No NCHAR, etc., in Drill (?).
+  private static int ordOptVARBINARY_16;
+  private static int ordOptBINARY_1048576;
+
+  private static int ordReqDATE;
+  private static int ordReqTIME_2;
+  private static int ordOptTIME_7;
+  private static int ordReqTIMESTAMP_4;
+  // No "... WITH TIME ZONE" in Drill.
+
+  private static int ordReqINTERVAL_Y;
+  private static int ordReqINTERVAL_3Y_Mo;
+  private static int ordReqINTERVAL_10Y_Mo;
+  private static int ordReqINTERVAL_Mo;
+  private static int ordReqINTERVAL_D;
+  private static int ordReqINTERVAL_4D_H;
+  private static int ordReqINTERVAL_3D_Mi;
+  private static int ordReqINTERVAL_2D_S5;
+  private static int ordReqINTERVAL_H;
+  private static int ordReqINTERVAL_1H_Mi;
+  private static int ordReqINTERVAL_3H_S1;
+  private static int ordReqINTERVAL_Mi;
+  private static int ordReqINTERVAL_5Mi_S;
+  private static int ordReqINTERVAL_S;
+  private static int ordReqINTERVAL_3S;
+  private static int ordReqINTERVAL_3S1;
+
+
+  @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;
+
+    // Create temporary test-columns view:
+    util = stmt.executeQuery( "USE `" + VIEW_SCHEMA + "`" );
+    assertTrue( util.next() );
+    assertTrue( "Error setting schema for test: " + util.getString( 2 ),
+                util.getBoolean( 1 ) );
+
+    columnCount = 0;
+    final StringBuilder buf = new StringBuilder();
+
+    buf.append( "CREATE OR REPLACE VIEW `" + VIEW_NAME + "` AS SELECT " );
+
+    buf.append( "\n CAST( NULL    AS BOOLEAN      ) AS mdrOptBOOLEAN, " );
+    ordOptBOOLEAN = ++columnCount;
+    buf.append( "\n TRUE                            AS mdrReqBOOLEAN, " );
+    ordReqBOOLEAN = ++columnCount;
+
+    //buf.append( "\n CAST(   15    AS SMALLINT     ) AS mdrOptSMALLINT, " );
+    //ordOptSMALLINT = ++columnCount;
+    buf.append( "\n CAST(    2    AS INTEGER      ) AS mdrOptINTEGER, " );
+    ordReqINTEGER = ++columnCount;
+    buf.append( "\n CAST( 15      AS BIGINT       ) AS mdrReqBIGINT, " );
+    ordReqBIGINT = ++columnCount;
+
+
+    // TODO(DRILL-2683): unignore when REAL is implemented:
+    //buf.append( "\n CAST(  3.1    AS REAL         ) AS mdrReqREAL, " );
+    //ordReqREAL = ++columnCount;
+    buf.append( "\n CAST(  3.2    AS FLOAT        ) AS mdrReqFLOAT, " );
+    ordReqFLOAT = ++columnCount;
+    buf.append( "\n CAST(  3.3    AS DOUBLE       ) AS mdrReqDOUBLE, " );
+    ordReqDOUBLE = ++columnCount;
+
+    buf.append( "\n CAST(  4.4    AS DECIMAL(5,3) ) AS mdrReqDECIMAL_5_3, " );
+    ordReqDECIMAL_5_3 = ++columnCount;
+
+    buf.append( "\n CAST( 'Hi'    AS VARCHAR(10)  ) AS mdrReqVARCHAR_10, " );
+    ordReqVARCHAR_10 = ++columnCount;
+    buf.append( "\n CAST( NULL    AS VARCHAR      ) AS mdrOptVARCHAR, " );
+    ordOptVARCHAR = ++columnCount;
+    buf.append( "\n CAST( '55'    AS CHAR(5)      ) AS mdrReqCHAR_5, " );
+    ordReqCHAR_5 = ++columnCount;
+
+    // TODO(DRILL-3368): unignore when VARBINARY is implemented enough:
+    //buf.append( "\n CAST( NULL    AS VARBINARY(16)      ) AS mdrOptVARBINARY_16," );
+    //ordOptVARBINARY_16 = ++columnCount;
+    // TODO(DRILL-3368): unignore when BINARY is implemented enough:
+    //buf.append( "\n CAST( NULL    AS BINARY(1048576)    ) AS mdrOptBINARY_1048576, " );
+    //ordOptBINARY_1048576 = ++columnCount;
+
+    buf.append( "\n       DATE '2015-01-01'            AS mdrReqDATE, " );
+    ordReqDATE = ++columnCount;
+    buf.append( "\n CAST( TIME '23:59:59.123' AS TIME(2) ) AS mdrReqTIME_2, " );
+    ordReqTIME_2 = ++columnCount;
+    buf.append( "\n CAST( NULL                AS TIME(7) ) AS mdrOptTIME_7, " );
+    ordOptTIME_7 = ++columnCount;
+    buf.append( "\n CAST( TIMESTAMP '2015-01-01 23:59:59.12345'"
+                +                  " AS TIMESTAMP(4) ) AS mdrReqTIMESTAMP_4, " );
+    ordReqTIMESTAMP_4 = ++columnCount;
+
+    buf.append( "\n INTERVAL '1'     YEAR              AS mdrReqINTERVAL_Y, " );
+    ordReqINTERVAL_Y = ++columnCount;
+    buf.append( "\n INTERVAL '1-2'   YEAR(3) TO MONTH  AS mdrReqINTERVAL_3Y_Mo, " );
+    ordReqINTERVAL_3Y_Mo = ++columnCount;
+    buf.append( "\n INTERVAL '1-2'   YEAR(10) TO MONTH AS mdrReqINTERVAL_10Y_Mo, " );
+    ordReqINTERVAL_10Y_Mo = ++columnCount;
+    buf.append( "\n INTERVAL '-2'    MONTH             AS mdrReqINTERVAL_Mo, " );
+    ordReqINTERVAL_Mo = ++columnCount;
+    buf.append( "\n INTERVAL '3'     DAY               AS mdrReqINTERVAL_D, " );
+    ordReqINTERVAL_D = ++columnCount;
+    buf.append( "\n INTERVAL '3 4'   DAY(4) TO HOUR    AS mdrReqINTERVAL_4D_H, " );
+    ordReqINTERVAL_4D_H = ++columnCount;
+    buf.append( "\n INTERVAL '3 4:5' DAY(3) TO MINUTE  AS mdrReqINTERVAL_3D_Mi, " );
+    ordReqINTERVAL_3D_Mi = ++columnCount;
+    buf.append( "\n INTERVAL '3 4:5:6' DAY(2) TO SECOND(5) AS mdrReqINTERVAL_2D_S5, " );
+    ordReqINTERVAL_2D_S5 = ++columnCount;
+    buf.append( "\n INTERVAL '4'     HOUR              AS mdrReqINTERVAL_H, " );
+    ordReqINTERVAL_H = ++columnCount;
+    buf.append( "\n INTERVAL '4:5'   HOUR(1) TO MINUTE AS mdrReqINTERVAL_1H_Mi, " );
+    ordReqINTERVAL_1H_Mi = ++columnCount;
+    buf.append( "\n INTERVAL '4:5:6' HOUR(3) TO SECOND(1) AS mdrReqINTERVAL_3H_S1, " );
+    ordReqINTERVAL_3H_S1 = ++columnCount;
+    buf.append( "\n INTERVAL '5'     MINUTE            AS mdrReqINTERVAL_Mi, " );
+    ordReqINTERVAL_Mi = ++columnCount;
+    buf.append( "\n INTERVAL '5:6'   MINUTE(5) TO SECOND AS mdrReqINTERVAL_5Mi_S, " );
+    ordReqINTERVAL_5Mi_S = ++columnCount;
+    buf.append( "\n INTERVAL '6'     SECOND          AS mdrReqINTERVAL_S, " );
+    ordReqINTERVAL_S = ++columnCount;
+    buf.append( "\n INTERVAL '6'     SECOND(3)       AS mdrReqINTERVAL_3S, " );
+    ordReqINTERVAL_3S = ++columnCount;
+    buf.append( "\n INTERVAL '6'     SECOND(3, 1)    AS mdrReqINTERVAL_3S1, " );
+    ordReqINTERVAL_3S1 = ++columnCount;
+
+    buf.append( "\n ''" );
+    ++columnCount;
+    buf.append( "\nFROM INFORMATION_SCHEMA.COLUMNS LIMIT 1 " );
+
+    final String query = buf.toString();
+    util = stmt.executeQuery( query );
+    assertTrue( util.next() );
+    assertTrue( "Error creating temporary test-columns view " + VIEW_NAME + ": "
+                + util.getString( 2 ), util.getBoolean( 1 ) );
+
+    viewRow = stmt.executeQuery( "SELECT * FROM " + VIEW_NAME + " LIMIT 1 " );
+    viewRow.next();
+
+    rowMetadata = viewRow.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();
+  }
+
+
+  //////////////////////////////////////////////////////////////////////
+  // Tests:
+
+  ////////////////////////////////////////////////////////////
+  // getColumnCount(...):
+  // JDBC: "Returns the number of columns in this ResultSet object."
+
+  @Test
+  public void test_getColumnCount() throws SQLException {
+    assertThat( "column count",
+                rowMetadata.getColumnCount(), equalTo( columnCount ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // isAutoIncrement(...):
+  // JDBC: "Indicates whether the designated column is automatically numbered."
+
+  @Test
+  public void test_isAutoIncrement_returnsFalse() throws SQLException {
+    assertThat( rowMetadata.isAutoIncrement( ordOptBOOLEAN ), equalTo( false ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // isCaseSensitive(...):
+  // JDBC: "Indicates whether a column's case matters."
+  // (Presumably that refers to the column's name, not values.)
+  // Matters for what (for which operations)?
+
+  @Test
+  public void test_isCaseSensitive_nameThisNonSpecific() throws SQLException {
+    assertThat( rowMetadata.isCaseSensitive( ordOptBOOLEAN ), equalTo( false ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // isSearchable(...):
+  // JDBC: "Indicates whether the designated column can be used in a where
+  //   clause."
+  // (Is there any reason a column couldn't be used in a WHERE clause?)
+
+  @Test
+  public void test_isSearchable_returnsTrue() throws SQLException {
+    assertThat( rowMetadata.isSearchable( ordOptBOOLEAN ), equalTo( true ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // isCurrency(...):
+  // JDBC: "Indicates whether the designated column is a cash value."
+
+  @Test
+  public void test_isCurrency_returnsFalse() throws SQLException {
+    assertThat( rowMetadata.isCurrency( ordOptBOOLEAN ), equalTo( false ) );
+  }
+
+  ////////////////////////////////////////////////////////////
+  // isNullable(...):
+  // JDBC: "Indicates the nullability of values in the designated column."
+
+  @Test
+  public void test_isNullable_forNullable() throws SQLException {
+    assertThat( rowMetadata.isNullable( ordOptBOOLEAN ),
+                equalTo( ResultSetMetaData.columnNullable) );
+  }
+
+  @Test
+  public void test_isNullable_forRequired() throws SQLException {
+    assertThat( rowMetadata.isNullable( ordReqINTEGER ),
+                equalTo( ResultSetMetaData.columnNoNulls) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // isSigned(...):
+  // JDBC: "Indicates whether values in the designated column are signed numbers."
+  // (Does "signed numbers" include intervals (which are signed)?
+
+  @Test
+  public void test_isSigned_forBOOLEAN() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordOptBOOLEAN ), equalTo( false ) );
+  }
+
+  @Test
+  public void test_isSigned_forINTEGER() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordReqINTEGER ), equalTo( true ) );
+  }
+
+  @Test
+  public void test_isSigned_forDOUBLE() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordReqDOUBLE ), equalTo( true ) );
+  }
+
+  @Test
+  public void test_isSigned_forDECIMAL_5_3() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordReqDECIMAL_5_3 ), equalTo( true ) );
+  }
+
+  @Test
+  public void test_isSigned_forVARCHAR() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordReqVARCHAR_10 ), equalTo( false ) );
+  }
+
+  @Test
+  @Ignore( "TODO(DRILL-3368): unignore when VARBINARY is implemented enough" )
+  public void test_isSigned_forBINARY_1048576() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordOptBINARY_1048576 ), equalTo( false ) );
+  }
+
+  @Test
+  public void test_isSigned_forDate() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordReqDATE ), equalTo( false ) );
+  }
+
+  @Test
+  public void test_isSigned_forTIME_2() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordReqTIME_2 ), equalTo( false ) );
+  }
+
+  @Test
+  public void test_isSigned_forTIMESTAMP_4() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordReqTIMESTAMP_4 ), equalTo( false ) );
+  }
+
+  @Test
+  public void test_isSigned_forINTERVAL_Y() throws SQLException {
+    assertThat( rowMetadata.isSigned( ordReqINTERVAL_Y ), equalTo( true ) );
+  }
+
+  // TODO(DRILL-3253):  Do more types when we have all-types test storage plugin.
+
+
+  ////////////////////////////////////////////////////////////
+  // getColumnDisplaySize(...):
+  // JDBC: "Indicates the designated column's normal maximum width in characters.
+  //   ... the normal maximum number of characters allowed as the width of the
+  //       designated column"
+  // (What exactly is the "normal maximum" number of characters?)
+
+  @Ignore( "TODO(DRILL-3355): unignore when getColumnDisplaySize(...) implemented" )
+  @Test
+  public void test_getColumnDisplaySize_forBOOLEAN() throws SQLException {
+    assertThat( rowMetadata.getColumnDisplaySize( ordOptBOOLEAN ),
+                equalTo( 5 ) );
+  }
+
+  // TODO(DRILL-3355):  Do more types when metadata is available.
+  // TODO(DRILL-3253):  Do more types when we have all-types test storage plugin.
+
+
+  ////////////////////////////////////////////////////////////
+  // getColumnLabel(...):
+  // JDBC: "Gets the designated column's suggested title for use in printouts
+  //   and displays. The suggested title is usually specified by the SQL
+  //   AS clause.  If a SQL AS is not specified, the value returned from
+  //   getColumnLabel will be the same as the value returned by the
+  //   getColumnName method."
+
+  @Test
+  public void test_getColumnLabel_getsName() throws SQLException {
+    assertThat( rowMetadata.getColumnLabel( ordOptBOOLEAN ),
+                equalTo( "mdrOptBOOLEAN" ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // getColumnName(...):
+  // JDBC: "Get the designated column's name."
+
+  @Test
+  public void test_getColumnName_getsName() throws SQLException {
+    assertThat( rowMetadata.getColumnName( ordOptBOOLEAN ),
+                equalTo( "mdrOptBOOLEAN" ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // getSchemaName(...):
+  // JDBC: "Get the designated column's table's schema. ... schema name
+  //   or "" if not applicable"
+  // Note: Schema _name_, not schema, of course.
+  // (Are result-set tables in a schema?)
+
+  @Test
+  public void test_getSchemaName_forViewGetsName() throws SQLException {
+    assertThat( rowMetadata.getSchemaName( ordOptBOOLEAN ),
+                anyOf( equalTo( VIEW_SCHEMA ),
+                       equalTo( "" ) ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // getPrecision(...):
+  // JDBC: "Get the designated column's specified column size.
+  //   For numeric data, this is the maximum precision.
+  //   For character data, this is the length in characters.
+  //   For datetime datatypes, this is the length in characters of the String
+  //     representation (assuming the maximum allowed precision of the
+  //     fractional seconds component).
+  //   For binary data, this is the length in bytes.
+  //   For the ROWID datatype, this is the length in bytes.
+  //   0 is returned for data types where the column size is not applicable."
+  // TODO(DRILL-3355):  Resolve:
+  // - Confirm:  This seems to be the same as getColumns's COLUMN_SIZE.
+  // - Is numeric "maximum precision" in bits, in digits, or per some radix
+  //   specified somewhere?
+  // - For which unmentioned types is column size applicable or not applicable?
+  //   E.g., what about interval types?
+
+  @Test
+  public void test_getPrecision_forBOOLEAN() throws SQLException {
+    assertThat( rowMetadata.getPrecision( ordOptBOOLEAN ), equalTo( 0 ) );
+  }
+
+  @Ignore( "TODO(DRILL-3355): unignore when getPrecision(...) implemented" )
+  @Test
+  public void test_getPrecision_forINTEGER() throws SQLException {
+    // Is it actual bits?:
+    assertThat( rowMetadata.getPrecision( ordReqINTEGER ), equalTo( 32 ) );
+    // Is it number of possible decimal digits?
+    assertThat( rowMetadata.getPrecision( ordReqINTEGER ), equalTo( 10 ) );
+    // Is it minimum guaranteed decimal digits?
+    assertThat( rowMetadata.getPrecision( ordReqINTEGER ), equalTo( 9 ) );
+  }
+
+  @Ignore( "TODO(DRILL-3355): unignore when getPrecision(...) implemented" )
+  @Test
+  public void test_getPrecision_forDOUBLE() throws SQLException {
+    // Is it actual bits?:
+    assertThat( rowMetadata.getPrecision( ordReqDOUBLE ), equalTo( 53 ) );
+    // Is it number of possible decimal digits?
+    assertThat( rowMetadata.getPrecision( ordReqINTEGER ), equalTo( 7 ) );
+    // Is it minimum guaranteed decimal digits?
+    assertThat( rowMetadata.getPrecision( ordReqDOUBLE ), equalTo( 6 ) );
+  }
+
+  @Ignore( "TODO(DRILL-3367): unignore when DECIMAL is no longer DOUBLE" )
+  @Test
+  public void test_getPrecision_forDECIMAL_5_3() throws SQLException {
+    assertThat( rowMetadata.getPrecision( ordReqDECIMAL_5_3 ), equalTo( 5 ) );
+  }
+
+  // TODO(DRILL-3355):  Do more types when metadata is available.
+  // - Copy in tests for DatabaseMetaData.getColumns(...)'s COLUMN_SIZE (since
+  //   ResultSetMetaData.getPrecision(...) seems to be defined the same.
+  // TODO(DRILL-3253):  Do more types when we have all-types test storage plugin.
+
+
+  ////////////////////////////////////////////////////////////
+  // getScale(...):
+  // JDBC: "Gets the designated column's number of digits to right of the
+  //   decimal point.  0 is returned for data types where the scale is not
+  //   applicable."
+  // (When exactly is scale not applicable?  What about for TIME or INTERVAL?)
+
+  @Test
+  public void test_getScale_forBOOLEAN() throws SQLException {
+    assertThat( rowMetadata.getScale( ordOptBOOLEAN ), equalTo( 0 ) );
+  }
+
+  @Test
+  public void test_getScale_forINTEGER() throws SQLException {
+    assertThat( rowMetadata.getScale( ordReqINTEGER ), equalTo( 0 ) );
+  }
+
+  @Ignore( "TODO(DRILL-3367): unignore when DECIMAL is no longer DOUBLE" )
+  @Test
+  public void test_getScale_forDECIMAL_5_3() throws SQLException {
+    assertThat( rowMetadata.getScale( ordReqDECIMAL_5_3 ), equalTo( 3 ) );
+  }
+
+  // TODO(DRILL-3355):  Do more types when metadata is available.
+  // - especially TIME and INTERVAL cases.
+  // TODO(DRILL-3253):  Do more types when we have all-types test storage plugin.
+
+
+  ////////////////////////////////////////////////////////////
+  // getTableName(...):
+  // JDBC: "Gets the designated column's table name. ... table name or "" if
+  //   not applicable"
+  // (When exactly is this applicable or not applicable?)
+
+  @Test
+  public void test_getTableName_forViewGetsName() throws SQLException {
+    assertThat( rowMetadata.getTableName( ordOptBOOLEAN ),
+                anyOf( equalTo( VIEW_NAME ),
+                       equalTo( "" ) ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // getCatalogName(...):
+  // JDBC: "Gets the designated column's table's catalog name.  ... the name of
+  //   the catalog for the table in which the given column appears or "" if not
+  //    applicable"
+  // (What if the result set is not directly from a base table?  Since Drill has
+  // has only one catalog ("DRILL") should this return "DRILL" for everything,
+  // or only for base tables?)
+
+  @Test
+  public void test_getCatalogName_getsCatalogName() throws SQLException {
+    assertThat( rowMetadata.getCatalogName( ordOptBOOLEAN ),
+                anyOf( equalTo( "DRILL" ), equalTo( "" ) ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // getColumnType(...):
+  // JDBC: "Retrieves the designated column's SQL type.  ... SQL type from
+  //   java.sql.Types"
+  // NOTE:  JDBC representation of data type or data type family.
+
+  @Test
+  public void test_getColumnType_forBOOLEAN() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordOptBOOLEAN ),
+                equalTo( Types.BOOLEAN ) );
+  }
+
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
+  @Test
+  public void test_getColumnType_forSMALLINT() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqSMALLINT ),
+                equalTo( Types.SMALLINT ) );
+  }
+
+  @Test
+  public void test_getColumnType_forINTEGER() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqINTEGER ),
+                equalTo( Types.INTEGER ) );
+  }
+
+  @Test
+  public void test_getColumnType_forBIGINT() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqBIGINT ),
+                equalTo( Types.BIGINT ) );
+  }
+
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
+  @Test
+  public void test_getColumnType_forREAL() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqREAL ),
+                equalTo( Types.REAL ) );
+  }
+
+  @Test
+  public void test_getColumnType_forFLOAT() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqFLOAT ),
+                equalTo( Types.FLOAT ) );
+  }
+
+  @Test
+  public void test_getColumnType_forDOUBLE() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqDOUBLE ),
+                equalTo( Types.DOUBLE ) );
+  }
+
+  @Ignore( "TODO(DRILL-3367): unignore when DECIMAL is no longer DOUBLE" )
+  @Test
+  public void test_getColumnType_forDECIMAL_5_3() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqDECIMAL_5_3 ),
+                equalTo( Types.DECIMAL ) );
+  }
+
+  @Test
+  public void test_getColumnType_forVARCHAR_10() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqVARCHAR_10 ),
+                equalTo( Types.VARCHAR ) );
+  }
+
+  @Test
+  public void test_getColumnType_forVARCHAR() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordOptVARCHAR ),
+                equalTo( Types.VARCHAR ) );
+  }
+
+  @Ignore( "TODO(DRILL-3369): unignore when CHAR is no longer VARCHAR" )
+  @Test
+  public void test_getColumnType_forCHAR_5() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqCHAR_5 ),
+                equalTo( Types.CHAR ) );
+  }
+
+  @Ignore( "TODO(DRILL-3368): unignore when VARBINARY is implemented enough" )
+  @Test
+  public void test_getColumnType_forVARBINARY_16() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordOptVARBINARY_16 ),
+                equalTo( Types.VARBINARY ) );
+  }
+
+  @Ignore( "TODO(DRILL-3368): unignore when BINARY is implemented enough" )
+  @Test
+  public void test_getColumnType_forBINARY_1048576CHECK() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordOptBINARY_1048576 ),
+                equalTo( Types.VARBINARY ) );
+  }
+
+  @Test
+  public void test_getColumnType_forDATE() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqDATE ),
+                equalTo( Types.DATE ) );
+  }
+
+  @Test
+  public void test_getColumnType_forTIME_2() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqTIME_2 ),
+                equalTo( Types.TIME ) );
+  }
+
+  @Test
+  public void test_getColumnType_forTIME_7() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordOptTIME_7 ),
+                equalTo( Types.TIME ) );
+  }
+
+  @Test
+  public void test_getColumnType_forTIMESTAMP_4() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqTIMESTAMP_4 ),
+                equalTo( Types.TIMESTAMP ) );
+  }
+
+  @Test
+  public void test_getColumnType_forINTERVAL_Y() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqINTERVAL_Y ),
+                equalTo( Types.OTHER ) );
+  }
+
+  @Test
+  public void test_getColumnType_forINTERVAL_H_S3() throws SQLException {
+    assertThat( rowMetadata.getColumnType( ordReqINTERVAL_3H_S1 ),
+                equalTo( Types.OTHER ) );
+  }
+
+  // TODO(DRILL-3253):  Do more types when we have all-types test storage plugin.
+
+
+  ////////////////////////////////////////////////////////////
+  // getColumnTypeName(...):
+  // JDBC: "Retrieves the designated column's database-specific type name.
+  //   ... type name used by the database.  If the column type is a user-defined
+  //   type, then a fully-qualified type name is returned."
+  // (Is this expected to match INFORMATION_SCHEMA.COLUMNS.TYPE_NAME?)
+
+  @Test
+  public void test_getColumnTypeName_forBOOLEAN() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordOptBOOLEAN ),
+                equalTo( "BOOLEAN" ) );
+  }
+
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
+  @Test
+  public void test_getColumnTypeName_forSMALLINT() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqSMALLINT ),
+                equalTo( "SMALLINT" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forINTEGER() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqINTEGER ),
+                equalTo( "INTEGER" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forBIGINT() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqBIGINT ),
+                equalTo( "BIGINT" ) );
+  }
+
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
+  @Test
+  public void test_getColumnTypeName_forREAL() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqREAL ),
+                equalTo( "REAL" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forFLOAT() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqFLOAT ),
+                equalTo( "FLOAT" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forDOUBLE() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqDOUBLE ),
+                equalTo( "DOUBLE" ) );
+  }
+
+  @Ignore( "TODO(DRILL-3367): unignore when DECIMAL is no longer DOUBLE" )
+  @Test
+  public void test_getColumnTypeName_forDECIMAL_5_3() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqDECIMAL_5_3 ),
+                equalTo( "DECIMAL" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forVARCHAR() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordOptVARCHAR ),
+                equalTo( "CHARACTER VARYING" ) );
+  }
+
+  @Ignore( "TODO(DRILL-3369): unignore when CHAR is no longer VARCHAR" )
+  @Test
+  public void test_getColumnTypeName_forCHAR() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqCHAR_5 ),
+                equalTo( "CHARACTER" ) );
+  }
+
+  @Ignore( "TODO(DRILL-3368): unignore when VARBINARY is implemented enough" )
+  @Test
+  public void test_getColumnTypeName_forVARBINARY() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordOptVARBINARY_16 ),
+                equalTo( "BINARY VARYING" ) );
+  }
+
+  @Ignore( "TODO(DRILL-3368): unignore when BINARY is implemented enough" )
+  @Test
+  public void test_getColumnTypeName_forBINARY() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordOptBINARY_1048576 ),
+                equalTo( "BINARY" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forDATE() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqDATE ),
+                equalTo( "DATE" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forTIME_2() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqTIME_2 ),
+                equalTo( "TIME" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forTIMESTAMP_4() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqTIMESTAMP_4 ),
+                equalTo( "TIMESTAMP" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forINTERVAL_Y() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqINTERVAL_Y ),
+                equalTo( "INTERVAL" ) );
+  }
+
+  @Test
+  public void test_getColumnTypeName_forINTERVAL_D() throws SQLException {
+    assertThat( rowMetadata.getColumnTypeName( ordReqINTERVAL_4D_H ),
+                equalTo( "INTERVAL" ) );
+  }
+
+  // TODO(DRILL-3253):  Do more types when we have all-types test storage plugin.
+
+
+  ////////////////////////////////////////////////////////////
+  // isReadOnly(...):
+  // JDBC: "Indicates whether the designated column is definitely not writable."
+  // (Writable in what context?  By current user in current connection? Some
+  // other context?)
+
+  @Test
+  public void test_isReadOnly_nameThisNonSpecific() throws SQLException {
+    assertThat( rowMetadata.isReadOnly( ordOptBOOLEAN ), equalTo( true ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // isWritable(...):
+  // JDBC: "Indicates whether it is possible for a write on the designated
+  //   column to succeed."
+  // (Possible in what context?  By current user in current connection?  Some
+  // other context?
+
+  @Test
+  public void test_isWritable_nameThisNonSpecific() throws SQLException {
+    assertThat( rowMetadata.isWritable( ordOptBOOLEAN ), equalTo( false ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // isDefinitelyWritable(...):
+  // JDBC: "Indicates whether a write on the designated column will definitely
+  //   succeed."
+  // (Will succeed in what context?  By current user in current connection?
+  // Some other context?)
+
+  @Test
+  public void test_isDefinitelyWritable_nameThisNonSpecific() throws SQLException {
+    assertThat( rowMetadata.isDefinitelyWritable( ordOptBOOLEAN ),
+                equalTo( false ) );
+  }
+
+
+  ////////////////////////////////////////////////////////////
+  // getColumnClassName(...):
+  // JDBC: "Returns the fully-qualified name of the Java class whose instances
+  //   are manufactured if the method ResultSet.getObject is called to retrieve
+  //   a value from the column.  ResultSet.getObject may return a subclass of
+  //   the class returned by this method. ... the fully-qualified name of the
+  //   class in the Java programming language that would be used by the method"
+
+  // BOOLEAN:
+
+  @Test
+  public void test_getColumnClassName_forBOOLEAN_isBoolean() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordOptBOOLEAN ),
+                equalTo( Boolean.class.getName() ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forBOOLEAN_matches() throws SQLException {
+    assertThat(
+        rowMetadata.getColumnClassName( ordReqBOOLEAN ),
+        // (equalTo because Boolean is final)
+        equalTo( viewRow.getObject( ordReqBOOLEAN ).getClass().getName() ) );
+  }
+
+  // SMALLINT:
+
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
+  @Test
+  public void test_getColumnClassName_forSMALLINT_isShort() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqSMALLINT ),
+                equalTo( Short.class.getName() ) );
+  }
+
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
+  @Test
+  public void test_getColumnClassName_forSMALLINT_matches() throws SQLException {
+    assertThat(
+        rowMetadata.getColumnClassName( ordReqSMALLINT ),
+        // (equalTo because Short is final)
+        equalTo( viewRow.getObject( ordReqSMALLINT ).getClass().getName() ) );
+  }
+
+  // INTEGER:
+
+  @Test
+  public void test_getColumnClassName_forINTEGER_isInteger() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqINTEGER ),
+                equalTo( Integer.class.getName() ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forINTEGER_matches() throws SQLException {
+    assertThat(
+        rowMetadata.getColumnClassName( ordReqINTEGER ),
+        // (equalTo because Integer is final)
+        equalTo( viewRow.getObject( ordReqINTEGER ).getClass().getName() ) );
+  }
+
+  // BIGINT:
+
+  @Test
+  public void test_getColumnClassName_forBIGINT_isLong() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqBIGINT ),
+                equalTo( Long.class.getName() ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forBIGINT_matches() throws SQLException {
+    assertThat(
+        rowMetadata.getColumnClassName( ordReqBIGINT ),
+        // (equalTo because Long is final)
+        equalTo( viewRow.getObject( ordReqBIGINT ).getClass().getName() ) );
+  }
+
+  // REAL:
+
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
+  @Test
+  public void test_getColumnClassName_forREAL_isFloat() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqREAL ),
+                equalTo( Float.class.getName() ) );
+  }
+
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
+  @Test
+  public void test_getColumnClassName_forREAL_matches() throws SQLException {
+    assertThat(
+        rowMetadata.getColumnClassName( ordReqREAL ),
+        // (equalTo because Float is final)
+        equalTo( viewRow.getObject( ordReqREAL ).getClass().getName() ) );
+  }
+
+  // FLOAT:
+
+  @Test
+  public void test_getColumnClassName_forFLOAT_isFloat() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqFLOAT ),
+                anyOf( equalTo( Float.class.getName() ),
+                       equalTo( Double.class.getName() ) ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forFLOAT_matches() throws SQLException {
+    assertThat(
+        rowMetadata.getColumnClassName( ordReqFLOAT ),
+        // (equalTo because Float is final)
+        equalTo( viewRow.getObject( ordReqFLOAT ).getClass().getName() ) );
+  }
+
+  // DOUBLE:
+
+  @Test
+  public void test_getColumnClassName_forDOUBLE_isDouble() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqDOUBLE ),
+                equalTo( Double.class.getName() ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forDOUBLE_matches() throws SQLException {
+    assertThat(
+        rowMetadata.getColumnClassName( ordReqDOUBLE ),
+        // (equalTo because Double is final)
+        equalTo( viewRow.getObject( ordReqDOUBLE ).getClass().getName() ) );
+  }
+
+  // DECIMAL_5_3:
+
+  @Ignore( "TODO(DRILL-3367): unignore when DECIMAL is no longer DOUBLE" )
+  @Test
+  public void test_getColumnClassName_forDECIMAL_5_3_isBigDecimal() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqDECIMAL_5_3 ),
+                equalTo( BigDecimal.class.getName() ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forDECIMAL_5_3_matches()
+      throws SQLException, ClassNotFoundException {
+    final Class<?> requiredClass =
+        Class.forName( rowMetadata.getColumnClassName( ordReqDECIMAL_5_3 ) );
+    final Class<?> actualClass = viewRow.getObject( ordReqDECIMAL_5_3 ).getClass();
+    assertTrue( "actual class " + actualClass.getName()
+                + " is not assignable to required class " + requiredClass,
+                requiredClass.isAssignableFrom( actualClass ) );
+  }
+
+  // VARCHAR_10:
+
+  @Test
+  public void test_getColumnClassName_forVARCHAR_10_isString() throws SQLException {
+    // TODO(DRILL-3347):  Resolve which type(s) to test for:
+    assertThat( rowMetadata.getColumnClassName( ordReqVARCHAR_10 ),
+                anyOf( equalTo( String.class.getName() ),
+                       equalTo( org.apache.hadoop.io.Text.class.getName() ) ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forVARCHAR_10_matches()
+      throws SQLException, ClassNotFoundException {
+    final Class<?> requiredClass =
+        Class.forName( rowMetadata.getColumnClassName( ordReqVARCHAR_10 ) );
+    final Class<?> actualClass = viewRow.getObject( ordReqVARCHAR_10 ).getClass();
+    assertTrue( "actual class " + actualClass.getName()
+                + " is not assignable to required class " + requiredClass,
+                requiredClass.isAssignableFrom( actualClass ) );
+  }
+
+  // TODO(DRILL-3369):  Add test when CHAR is no longer VARCHAR:
+  // CHAR_5:
+  // TODO(DRILL-3368):  Add test when VARBINARY is implemented enough:
+  // VARBINARY_16
+  // TODO(DRILL-3368):  Add test when BINARY is implemented enough:
+  // BINARY_1048576:
+
+  // DATE:
+
+  @Test
+  public void test_getColumnClassName_forDATE_isDate() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqDATE ),
+                equalTo( Date.class.getName() ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forDATE_matches()
+      throws SQLException, ClassNotFoundException {
+    final Class<?> requiredClass =
+        Class.forName( rowMetadata.getColumnClassName( ordReqDATE ) );
+     final Class<?> actualClass = viewRow.getObject( ordReqDATE ).getClass();
+     assertTrue(
+        "actual class " + actualClass.getName()
+        + " is not assignable to required class " + requiredClass,
+        requiredClass.isAssignableFrom( actualClass ) );
+  }
+
+  // TIME:
+
+  @Test
+  public void test_getColumnClassName_forTIME_2_isTime() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqTIME_2 ),
+                equalTo( Time.class.getName() ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forTIME_2_matches()
+      throws SQLException, ClassNotFoundException {
+    final Class<?> requiredClass =
+        Class.forName( rowMetadata.getColumnClassName( ordReqTIME_2 ) );
+    final Class<?> actualClass = viewRow.getObject( ordReqTIME_2 ).getClass();
+    assertTrue(
+        "actual class " + actualClass.getName()
+        + " is not assignable to required class " + requiredClass,
+        requiredClass.isAssignableFrom( actualClass ) );
+  }
+
+  // TIME_7:
+
+  // TIMESTAMP:
+
+  @Test
+  public void test_getColumnClassName_forTIMESTAMP_4_isDate() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqTIMESTAMP_4 ),
+                equalTo( Timestamp.class.getName() ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forTIMESTAMP_4_matches()
+      throws SQLException, ClassNotFoundException {
+    final Class<?> requiredClass =
+        Class.forName( rowMetadata.getColumnClassName( ordReqTIMESTAMP_4 ) );
+    final Class<?> actualClass =
+        viewRow.getObject( ordReqTIMESTAMP_4 ).getClass();
+    assertTrue(
+        "actual class " + actualClass.getName()
+        + " is not assignable to required class " + requiredClass,
+        requiredClass.isAssignableFrom( actualClass ) );
+  }
+
+  // No "... WITH TIME ZONE" in Drill.
+
+  // INTERVAL_Y:
+
+  // INTERVAL_3Y_Mo:
+
+  // INTERVAL_10Y_Mo:
+
+  @Test
+  public void test_getColumnClassName_forINTERVAL_10Y_Mo_isJodaPeriod() throws SQLException {
+    assertThat( rowMetadata.getColumnClassName( ordReqINTERVAL_10Y_Mo ),
+                equalTo( org.joda.time.Period.class.getName() ) );
+  }
+
+  @Test
+  public void test_getColumnClassName_forINTERVAL_10Y_Mo_matches()
+      throws SQLException, ClassNotFoundException {
+    final Class<?> requiredClass =
+        Class.forName( rowMetadata.getColumnClassName( ordReqINTERVAL_10Y_Mo ) );
+    final Class<?> actualClass =
+        viewRow.getObject( ordReqINTERVAL_10Y_Mo ).getClass();
+    assertTrue( "actual class " + actualClass.getName()
+                + " is not assignable to required class " + requiredClass,
+                requiredClass.isAssignableFrom( actualClass ) );
+  }
+
+  // TODO(DRILL-3253):  Do more types when we have all-types test storage plugin.
+
+
+} // class DatabaseMetaGetColumnsDataTest

http://git-wip-us.apache.org/repos/asf/drill/blob/80835082/exec/jdbc/src/test/java/org/apache/drill/jdbc/impl/TypeConvertingSqlAccessorTest.java
----------------------------------------------------------------------
diff --git a/exec/jdbc/src/test/java/org/apache/drill/jdbc/impl/TypeConvertingSqlAccessorTest.java b/exec/jdbc/src/test/java/org/apache/drill/jdbc/impl/TypeConvertingSqlAccessorTest.java
index a595ed4..3a4b83e 100644
--- a/exec/jdbc/src/test/java/org/apache/drill/jdbc/impl/TypeConvertingSqlAccessorTest.java
+++ b/exec/jdbc/src/test/java/org/apache/drill/jdbc/impl/TypeConvertingSqlAccessorTest.java
@@ -59,6 +59,11 @@ public class TypeConvertingSqlAccessorTest {
     }
 
     @Override
+    public Class<?> getObjectClass() {
+      throw new RuntimeException( "Unexpected use of getObjectClass(...)" );
+    }
+
+    @Override
     public MajorType getType() {
       return type;
     }

http://git-wip-us.apache.org/repos/asf/drill/blob/80835082/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
index 8fb521e..4e076b7 100644
--- 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
@@ -40,7 +40,7 @@ import static java.sql.ResultSetMetaData.columnNullable;
 import java.sql.SQLException;
 import java.sql.Types;
 
-// NOTE: TempInformationSchemaColumnsTest and DatabaseMetaDataGetColumnsTest
+// NOTE: TestInformationSchemaColumns and DatabaseMetaDataGetColumnsTest
 // have identical sections.  (Cross-maintain them for now; factor out later.)
 
 // TODO:  Review nullability (NULLABLE and IS_NULLABLE columns):
@@ -208,7 +208,9 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertTrue( util.next() );
     assertTrue( "Error setting schema for test: " + util.getString( 2 ), util.getBoolean( 1 ) );
 
-    // TODO(DRILL-2470): re-enable TINYINT, SMALLINT, and REAL.
+    // TODO(DRILL-2470): Adjust when TINYINT is implemented:
+    // TODO(DRILL-2470): Adjust when SMALLINT is implemented:
+    // TODO(DRILL-2683): Adjust when REAL is implemented:
     util = stmt.executeQuery(
         ""
         +   "CREATE OR REPLACE VIEW " + VIEW_NAME + " AS SELECT "
@@ -265,13 +267,14 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
 
     mdrOptBOOLEAN        = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptBOOLEAN" );
 
-    // TODO(DRILL-2470): re-enable TINYINT, SMALLINT, and REAL.
+    // TODO(DRILL-2470): Uncomment when TINYINT is implemented:
     //mdrReqTINYINT        = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqTINYINT" );
+    // TODO(DRILL-2470): Uncomment when SMALLINT is implemented:
     //mdrOptSMALLINT       = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptSMALLINT" );
     mdrReqINTEGER        = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqINTEGER" );
     mdrOptBIGINT         = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptBIGINT" );
 
-    // TODO(DRILL-2470): re-enable TINYINT, SMALLINT, and REAL.
+    // TODO(DRILL-2683): Uncomment when REAL is implemented:
     //mdrOptREAL           = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptREAL" );
     mdrOptFLOAT          = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrOptFLOAT" );
     mdrReqDOUBLE         = setUpRow( VIEW_SCHEMA, VIEW_NAME, "mdrReqDOUBLE" );
@@ -437,7 +440,8 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
 
   @Test
   public void test_TABLE_CATALOG_hasRightTypeString() throws SQLException {
-    assertThat( rowsMetadata.getColumnTypeName( 1 ), equalTo( "VARCHAR" ) );
+    assertThat( rowsMetadata.getColumnTypeName( 1 ),
+                equalTo( "CHARACTER VARYING" ) );
   }
 
   @Test
@@ -472,7 +476,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   // Not bothering with other _local_view_ test columns for TABLE_SCHEM.
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_TABLE_SCHEMA_hasRightValue_tdbARRAY() throws SQLException {
     assertThat( mdrReqARRAY.getString( "TABLE_SCHEMA" ), equalTo( "hive_test.default" ) );
   }
@@ -486,7 +490,8 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
 
   @Test
   public void test_TABLE_SCHEMA_hasRightTypeString() throws SQLException {
-    assertThat( rowsMetadata.getColumnTypeName( 2 ), equalTo( "VARCHAR" ) );
+    assertThat( rowsMetadata.getColumnTypeName( 2 ),
+                equalTo( "CHARACTER VARYING" ) );
   }
 
   @Test
@@ -527,7 +532,8 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
 
   @Test
   public void test_TABLE_NAME_hasRightTypeString() throws SQLException {
-    assertThat( rowsMetadata.getColumnTypeName( 3 ), equalTo( "VARCHAR" ) );
+    assertThat( rowsMetadata.getColumnTypeName( 3 ),
+                equalTo( "CHARACTER VARYING" ) );
   }
 
   @Test
@@ -562,7 +568,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   // Not bothering with other _local_view_ test columns for TABLE_SCHEM.
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_COLUMN_NAME_hasRightValue_tdbARRAY() throws SQLException {
     assertThat( mdrReqARRAY.getString( "COLUMN_NAME" ), equalTo( "listtype" ) );
   }
@@ -576,7 +582,8 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
 
   @Test
   public void test_COLUMN_NAME_hasRightTypeString() throws SQLException {
-    assertThat( rowsMetadata.getColumnTypeName( 4 ), equalTo( "VARCHAR" ) );
+    assertThat( rowsMetadata.getColumnTypeName( 4 ),
+                equalTo( "CHARACTER VARYING" ) );
   }
 
   @Test
@@ -608,13 +615,13 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( mdrOptBOOLEAN.getInt( "ORDINAL_POSITION" ), equalTo( 1 ) );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_ORDINAL_POSITION_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( mdrReqTINYINT.getInt( "ORDINAL_POSITION" ), equalTo( 2 ) );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_ORDINAL_POSITION_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( mdrOptSMALLINT.getInt( "ORDINAL_POSITION" ), equalTo( 3 ) );
@@ -630,7 +637,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( mdrOptBIGINT.getInt( "ORDINAL_POSITION" ), equalTo( 5 ) );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_ORDINAL_POSITION_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( mdrOptREAL.getInt( "ORDINAL_POSITION" ), equalTo( 6 ) );
@@ -647,7 +654,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_ORDINAL_POSITION_hasRightValue_tdbARRAY() throws SQLException {
     assertThat( mdrReqARRAY.getInt( "ORDINAL_POSITION" ), equalTo( 14 ) );
   }
@@ -693,7 +700,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   // Not bothering with other _local_view_ test columns for COLUMN_DEFAULT.
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_COLUMN_DEFAULT_hasRightValue_tdbARRAY() throws SQLException {
     assertThat( mdrReqARRAY.getString( "COLUMN_DEFAULT" ), nullValue() );
   }
@@ -707,7 +714,8 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
 
   @Test
   public void test_COLUMN_DEFAULT_hasRightTypeString() throws SQLException {
-    assertThat( rowsMetadata.getColumnTypeName( 6 ), equalTo( "VARCHAR" ) );
+    assertThat( rowsMetadata.getColumnTypeName( 6 ),
+                equalTo( "CHARACTER VARYING" ) );
   }
 
   @Test
@@ -741,14 +749,14 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
                 mdrOptBOOLEAN.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_IS_NULLABLE_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( "ResultSetMetaData.column...Null... nullability code:",
                 mdrReqTINYINT.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_IS_NULLABLE_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( "ResultSetMetaData.column...Null... nullability code:",
@@ -767,7 +775,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
                 mdrOptBIGINT.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_IS_NULLABLE_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( "ResultSetMetaData.column...Null... nullability code:",
@@ -859,20 +867,20 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   @Test
   public void test_IS_NULLABLE_hasRightValue_tbdSTRUCT() throws SQLException {
     assertThat( mdrUnkSTRUCT.getString( "IS_NULLABLE" ), equalTo( "YES" ) );
@@ -880,7 +888,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( mdrUnkSTRUCT.getString( "IS_NULLABLE" ), equalTo( "NO" ) );
   }
 
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   @Test
   public void test_IS_NULLABLE_hasRightValue_tbdUnion() throws SQLException {
     assertThat( "ResultSetMetaData.column...Null... nullability code:",
@@ -897,7 +905,8 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
 
   @Test
   public void test_IS_NULLABLE_hasRightTypeString() throws SQLException {
-    assertThat( rowsMetadata.getColumnTypeName( 7 ), equalTo( "VARCHAR" ) );
+    assertThat( rowsMetadata.getColumnTypeName( 7 ),
+                equalTo( "CHARACTER VARYING" ) );
   }
 
   @Test
@@ -929,13 +938,13 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( mdrOptBOOLEAN.getString( "DATA_TYPE" ), equalTo( "BOOLEAN" ) );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_DATA_TYPE_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( mdrReqTINYINT.getString( "DATA_TYPE" ), equalTo( "TINYINT" ) );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_DATA_TYPE_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( mdrOptSMALLINT.getString( "DATA_TYPE" ), equalTo( "SMALLINT" ) );
@@ -951,7 +960,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( mdrOptBIGINT.getString( "DATA_TYPE" ), equalTo( "BIGINT" ) );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_DATA_TYPE_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( mdrOptREAL.getString( "DATA_TYPE" ), equalTo( "REAL" ) );
@@ -992,7 +1001,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( mdrOptVARBINARY_16.getString( "DATA_TYPE" ), equalTo( "BINARY VARYING" ) );
   }
 
-  @Ignore( "until BINARY is actually BINARY and not VARBINARY (DRILL-xxxx)" )
+  @Ignore( "TODO(DRILL-3368): unignore when BINARY is implemented enough" )
   @Test
   public void test_DATA_TYPE_hasRightValue_mdrOptBINARY_1048576() throws SQLException {
     assertThat( mdrOptBINARY_1048576.getString( "DATA_TYPE" ), equalTo( "BINARY VARYING" ) ); // ?? current
@@ -1032,25 +1041,25 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_DATA_TYPE_hasRightValue_tbdUnion() throws SQLException {
     assertThat( mdrUnkUnion.getString( "DATA_TYPE" ), equalTo( "OTHER" ) );
     fail( "Expected value is not resolved yet." );
@@ -1063,7 +1072,8 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
 
   @Test
   public void test_DATA_TYPE_hasRightTypeString() throws SQLException {
-    assertThat( rowsMetadata.getColumnTypeName( 8 ), equalTo( "VARCHAR" ) );
+    assertThat( rowsMetadata.getColumnTypeName( 8 ),
+                equalTo( "CHARACTER VARYING" ) );
   }
 
   @Test
@@ -1095,13 +1105,13 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBOOLEAN, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( getIntOrNull( mdrReqTINYINT, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( getIntOrNull( mdrOptSMALLINT, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
@@ -1117,7 +1127,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBIGINT, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( getIntOrNull( mdrOptREAL, "CHARACTER_MAXIMUM_LENGTH" ), nullValue() );
@@ -1194,25 +1204,25 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_CHARACTER_MAXIMUM_LENGTH_hasRightValue_tbdUnion() throws SQLException {
     assertThat( getIntOrNull( mdrUnkUnion, "CHARACTER_MAXIMUM_LENGTH"), nullValue() );
   }
@@ -1255,19 +1265,19 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBOOLEAN, "CHARACTER_OCTET_LENGTH" ), nullValue() );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( getIntOrNull( mdrReqTINYINT, "CHARACTER_OCTET_LENGTH" ), nullValue() );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptBIGINT() throws SQLException {
     assertThat( getIntOrNull( mdrOptREAL, "CHARACTER_OCTET_LENGTH" ), nullValue() );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( getIntOrNull( mdrOptSMALLINT, "CHARACTER_OCTET_LENGTH" ), nullValue() );
@@ -1278,7 +1288,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrReqINTEGER, "CHARACTER_OCTET_LENGTH" ), nullValue() );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_CHARACTER_OCTET_LENGTH_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( getIntOrNull( mdrOptREAL, "CHARACTER_OCTET_LENGTH" ), nullValue() );
@@ -1361,25 +1371,25 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_CHARACTER_OCTET_LENGTH_hasRightValue_tbdUnion() throws SQLException {
     assertThat( getIntOrNull( mdrUnkUnion, "CHARACTER_OCTET_LENGTH"), nullValue() );
   }
@@ -1422,13 +1432,13 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBOOLEAN, "NUMERIC_PRECISION" ), nullValue() );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_NUMERIC_PRECISION_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( getIntOrNull( mdrReqTINYINT, "NUMERIC_PRECISION" ), equalTo( 8 ) );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_NUMERIC_PRECISION_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( getIntOrNull( mdrOptSMALLINT, "NUMERIC_PRECISION" ), equalTo( 16 ) );
@@ -1444,7 +1454,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBIGINT, "NUMERIC_PRECISION" ), equalTo( 64 ) );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_NUMERIC_PRECISION_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( getIntOrNull( mdrOptREAL, "NUMERIC_PRECISION" ), equalTo( 24 ) );
@@ -1521,25 +1531,25 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_NUMERIC_PRECISION_hasRightValue_tbdUnion() throws SQLException {
     assertThat( getIntOrNull( mdrUnkUnion, "NUMERIC_PRECISION" ), nullValue() );
   }
@@ -1582,13 +1592,13 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBOOLEAN, "NUMERIC_PRECISION_RADIX" ), nullValue() );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( getIntOrNull( mdrReqTINYINT, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( getIntOrNull( mdrOptSMALLINT, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
@@ -1604,7 +1614,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBIGINT, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_NUMERIC_PRECISION_RADIX_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( getIntOrNull( mdrOptREAL, "NUMERIC_PRECISION_RADIX" ), equalTo( 2 ) );
@@ -1681,25 +1691,25 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_NUMERIC_PRECISION_RADIX_hasRightValue_tbdUnion() throws SQLException {
     assertThat( getIntOrNull( mdrUnkUnion, "NUMERIC_PRECISION_RADIX" ), nullValue() );
   }
@@ -1742,13 +1752,13 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBOOLEAN, "NUMERIC_SCALE" ), nullValue() );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_NUMERIC_SCALE_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( getIntOrNull( mdrReqTINYINT, "NUMERIC_SCALE" ), equalTo( 0 ) );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_NUMERIC_SCALE_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( getIntOrNull( mdrOptSMALLINT, "NUMERIC_SCALE" ), equalTo( 0 ) );
@@ -1764,7 +1774,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBIGINT, "NUMERIC_SCALE" ), equalTo( 0 ) );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_NUMERIC_SCALE_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( getIntOrNull( mdrOptREAL, "NUMERIC_SCALE" ), nullValue() );
@@ -1841,25 +1851,25 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_NUMERIC_SCALE_hasRightValue_tbdUnion() throws SQLException {
     assertThat( getIntOrNull( mdrUnkUnion, "NUMERIC_SCALE" ), nullValue() );
   }
@@ -1902,13 +1912,13 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBOOLEAN, "DATETIME_PRECISION" ), nullValue() );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_DATETIME_PRECISION_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( getIntOrNull( mdrReqTINYINT, "DATETIME_PRECISION" ), nullValue() );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_DATETIME_PRECISION_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( getIntOrNull( mdrOptSMALLINT, "DATETIME_PRECISION" ), nullValue() );
@@ -1924,7 +1934,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBIGINT, "DATETIME_PRECISION" ), nullValue() );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_DATETIME_PRECISION_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( getIntOrNull( mdrOptREAL, "DATETIME_PRECISION" ), nullValue() );
@@ -1983,14 +1993,14 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrReqTIME, "DATETIME_PRECISION" ), equalTo( 0 ) );
   }
 
-  @Ignore( "until datetime precision is implemented" )
+  @Ignore( "TODO(DRILL-3225): unignore when 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" )
+  @Ignore( "TODO(DRILL-3225): unignore when 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 ) );
@@ -2038,7 +2048,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrReqINTERVAL_3D_Mi, "DATETIME_PRECISION" ), equalTo( 6 ) );
   }
 
-  @Ignore( "until fixed:  fractional secs. prec. gets wrong value (DRILL-3244)" )
+  @Ignore( "TODO(DRILL-3244): unignore when fractional secs. prec. is right" )
   @Test
   public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_2D_S5() throws SQLException {
     assertThat( getIntOrNull( mdrReqINTERVAL_2D_S5, "DATETIME_PRECISION" ), equalTo( 5 ) );
@@ -2068,7 +2078,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrReqINTERVAL_1H_Mi, "DATETIME_PRECISION" ), equalTo( 6 ) );
   }
 
-  @Ignore( "until fixed:  fractional secs. prec. gets start unit prec. (DRILL-3244) " )
+  @Ignore( "TODO(DRILL-3244): unignore when fractional secs. prec. is right" )
   @Test
   public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_H_S3() throws SQLException {
     assertThat( getIntOrNull( mdrReqINTERVAL_3H_S1, "DATETIME_PRECISION" ), equalTo( 1 ) );
@@ -2107,7 +2117,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrReqINTERVAL_3S, "DATETIME_PRECISION" ), equalTo( 6 ) );
   }
 
-  @Ignore( "until fixed:  fractional secs. prec. gets start unit prec. (DRILL-3244) " )
+  @Ignore( "TODO(DRILL-3244): unignore when fractional secs. prec. is right" )
   @Test
   public void test_DATETIME_PRECISION_hasRightValue_mdrReqINTERVAL_3S1() throws SQLException {
     assertThat( getIntOrNull( mdrReqINTERVAL_3S1, "DATETIME_PRECISION" ), equalTo( 1 ) );
@@ -2120,25 +2130,25 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   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)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_DATETIME_PRECISION_hasRightValue_tbdUnion() throws SQLException {
     assertThat( getIntOrNull( mdrUnkUnion, "DATETIME_PRECISION" ), nullValue() );
   }
@@ -2181,13 +2191,13 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( mdrOptBOOLEAN.getString( "INTERVAL_TYPE" ), nullValue() );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_INTERVAL_TYPE_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( mdrReqTINYINT.getString( "INTERVAL_TYPE" ), nullValue() );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_INTERVAL_TYPE_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( mdrOptSMALLINT.getString( "INTERVAL_TYPE" ), nullValue() );
@@ -2203,7 +2213,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( mdrOptBIGINT.getString( "INTERVAL_TYPE" ), nullValue() );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_INTERVAL_TYPE_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( mdrOptREAL.getString( "INTERVAL_TYPE" ), nullValue() );
@@ -2352,25 +2362,25 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_INTERVAL_TYPE_hasRightValue_tdbARRAY() throws SQLException {
     assertThat( mdrReqARRAY.getString( "INTERVAL_TYPE" ), nullValue() );
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_INTERVAL_TYPE_hasRightValue_tbdMAP() throws SQLException {
     assertThat( mdrReqMAP.getString( "INTERVAL_TYPE" ), nullValue() );
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_INTERVAL_TYPE_hasRightValue_tbdSTRUCT() throws SQLException {
     assertThat( getIntOrNull( mdrUnkSTRUCT, "INTERVAL_TYPE" ), nullValue() );
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_INTERVAL_TYPE_hasRightValue_tbdUnion() throws SQLException {
     assertThat( getIntOrNull( mdrUnkUnion, "INTERVAL_TYPE" ), nullValue() );
   }
@@ -2382,7 +2392,8 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
 
   @Test
   public void test_INTERVAL_TYPE_hasRightTypeString() throws SQLException {
-    assertThat( rowsMetadata.getColumnTypeName( 15 ), equalTo( "VARCHAR" ) );
+    assertThat( rowsMetadata.getColumnTypeName( 15 ),
+                equalTo( "CHARACTER VARYING" ) );
   }
 
   @Test
@@ -2413,13 +2424,13 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBOOLEAN, "INTERVAL_PRECISION" ), nullValue() );
   }
 
-  @Ignore( "until TINYINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when TINYINT is implemented" )
   @Test
   public void test_INTERVAL_PRECISION_hasRightValue_mdrReqTINYINT() throws SQLException {
     assertThat( getIntOrNull( mdrReqTINYINT, "INTERVAL_PRECISION" ), nullValue() );
   }
 
-  @Ignore( "until SMALLINT is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2470): unignore when SMALLINT is implemented" )
   @Test
   public void test_INTERVAL_PRECISION_hasRightValue_mdrOptSMALLINT() throws SQLException {
     assertThat( getIntOrNull( mdrOptSMALLINT, "INTERVAL_PRECISION" ), nullValue() );
@@ -2435,7 +2446,7 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
     assertThat( getIntOrNull( mdrOptBIGINT, "INTERVAL_PRECISION" ), nullValue() );
   }
 
-  @Ignore( "until REAL is implemented. (DRILL-2470)" )
+  @Ignore( "TODO(DRILL-2683): unignore when REAL is implemented" )
   @Test
   public void test_INTERVAL_PRECISION_hasRightValue_mdrOptREAL() throws SQLException {
     assertThat( getIntOrNull( mdrOptREAL, "INTERVAL_PRECISION" ), nullValue() );
@@ -2582,25 +2593,25 @@ public class TestInformationSchemaColumns extends JdbcTestBase {
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_INTERVAL_PRECISION_hasRightValue_tdbARRAY() throws SQLException {
     assertThat( getIntOrNull( mdrReqARRAY, "INTERVAL_PRECISION" ), nullValue() );
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_INTERVAL_PRECISION_hasRightValue_tbdMAP() throws SQLException {
     assertThat( getIntOrNull( mdrReqMAP, "INTERVAL_PRECISION" ), nullValue() );
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_INTERVAL_PRECISION_hasRightValue_tbdSTRUCT() throws SQLException {
     assertThat( getIntOrNull( mdrUnkSTRUCT, "INTERVAL_PRECISION" ), nullValue() );
   }
 
   @Test
-  @Ignore( "until we have test plugin supporting all needed types (DRILL-3253)." )
+  @Ignore( "TODO(DRILL-3253): unignore when we have all-types test storage plugin" )
   public void test_INTERVAL_PRECISION_hasRightValue_tbdUnion() throws SQLException {
     assertThat( getIntOrNull( mdrUnkUnion, "INTERVAL_PRECISION" ), nullValue() );
   }


Mime
View raw message