DRILL-2769: Fix most non-SQLException not-supported-yet exceptions.

Core:

Added (auto-scanning) unit test. [Drill2769UnsupportedReportsUseSqlExceptionTest]

Added translation of lots of UnsupportedOperationExceptions (and some
RuntimeExceptions) from Avatica code to SQLFeatureNotSupportedExceptions (tons
of method overrides).

Also:

Added explicit bounds checks in ResultSetMetaData methods and checking of
last-accessed column in DrillAccessorList.wasNull() (to fix other
RuntimeExceptions to SQLExceptions).

Added resetting of last-accessed column to fix latent bug in DrillAccessorList.

Hygiene:
- Renamed some zero-based index/ordinal-position parameters to "...Offset".
- Renamed some one-based index/ordinal-position parameters to "...Number".
- Renamed DrillAccessorList lastColumn to rowLastColumnOffset; declared
  explicit logical null value for rowLastColumnOffset.

exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillAccessorList.java

@@ -26,15 +26,34 @@
 import org.apache.drill.exec.vector.ValueVector;
 import org.apache.drill.exec.vector.accessor.BoundCheckingAccessor;
 import org.apache.drill.exec.vector.accessor.SqlAccessor;
+import org.apache.drill.jdbc.JdbcApiSqlException;
 
 
-class DrillAccessorList extends BasicList<Accessor>{
-  static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(DrillAccessorList.class);
+class DrillAccessorList extends BasicList<Accessor> {
+
+  @SuppressWarnings("unused")
+  private static final org.slf4j.Logger logger =
+      org.slf4j.LoggerFactory.getLogger(DrillAccessorList.class);
+  /** "None" value for rowLastColumnOffset. */
+  // (Not -1, since -1 can result from 0 (bad 1-based index) minus 1 (offset
+  // from 1-based to 0-based indexing.)
+  private static final int NULL_LAST_COLUMN_INDEX = -2;
 
   private AvaticaDrillSqlAccessor[] accessors = new AvaticaDrillSqlAccessor[0];
-  // TODO  Rename to lastColumnAccessed and/or document.
-  // TODO  Why 1, rather than, say, -1?
-  private int lastColumn = 1;
+
+  /** Zero-based offset of last column referenced in current row.
+   *  For {@link #wasNull()}. */
+  private int rowLastColumnOffset = NULL_LAST_COLUMN_INDEX;
+
+
+  /**
+   * Resets last-column-referenced information for {@link #wasNull}.
+   * Must be called whenever row is advanced (when {@link ResultSet#next()}
+   * is called).
+   */
+  void clearLastColumnIndexedInRow() {
+    rowLastColumnOffset = NULL_LAST_COLUMN_INDEX;
+  }
 
   void generateAccessors(DrillCursor cursor, RecordBatchLoader currentBatch) {
     int cnt = currentBatch.getSchema().getFieldCount();
@@ -47,16 +66,29 @@ void generateAccessors(DrillCursor cursor, RecordBatchLoader currentBatch) {
               );
       accessors[i] = new AvaticaDrillSqlAccessor(acc, cursor);
     }
+    clearLastColumnIndexedInRow();
   }
 
+  /**
+   * @param  accessorOffset  0-based index of accessor array (not 1-based SQL
+   *           column index/ordinal value)
+   */
   @Override
-  public AvaticaDrillSqlAccessor get(int index) {
-    lastColumn = index;
-    return accessors[index];
+  public AvaticaDrillSqlAccessor get(final int accessorOffset) {
+    final AvaticaDrillSqlAccessor accessor = accessors[accessorOffset];
+    // Update lastColumnIndexedInRow after indexing accessors to not touch
+    // lastColumnIndexedInRow in case of out-of-bounds exception.
+    rowLastColumnOffset = accessorOffset;
+    return accessor;
   }
 
   boolean wasNull() throws SQLException{
-    return accessors[lastColumn].wasNull();
+    if (NULL_LAST_COLUMN_INDEX == rowLastColumnOffset) {
+      throw new JdbcApiSqlException(
+          "ResultSet.wasNull() called without a preceding call to a column"
+          + " getter method since the last call to ResultSet.next()");
+    }
+    return accessors[rowLastColumnOffset].wasNull();
   }
 
   @Override

exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillConnectionImpl.java

@@ -406,13 +406,23 @@ public PreparedStatement prepareStatement(String sql) throws SQLException {
   @Override
   public CallableStatement prepareCall(String sql) throws SQLException {
     throwIfClosed();
-    return super.prepareCall(sql);
+    try {
+      return super.prepareCall(sql);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public String nativeSQL(String sql) throws SQLException {
     throwIfClosed();
-    return super.nativeSQL(sql);
+    try {
+      return super.nativeSQL(sql);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
 
@@ -496,19 +506,34 @@ public PreparedStatement prepareStatement(String sql, int resultSetType,
   public CallableStatement prepareCall(String sql, int resultSetType,
                                        int resultSetConcurrency) throws SQLException {
     throwIfClosed();
-    return super.prepareCall(sql, resultSetType, resultSetConcurrency);
+    try {
+      return super.prepareCall(sql, resultSetType, resultSetConcurrency);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public Map<String,Class<?>> getTypeMap() throws SQLException {
     throwIfClosed();
-    return super.getTypeMap();
+    try {
+      return super.getTypeMap();
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public void setTypeMap(Map<String,Class<?>> map) throws SQLException {
     throwIfClosed();
-    super.setTypeMap(map);
+    try {
+      super.setTypeMap(map);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
@@ -528,59 +553,104 @@ public CallableStatement prepareCall(String sql, int resultSetType,
                                        int resultSetConcurrency,
                                        int resultSetHoldability) throws SQLException {
     throwIfClosed();
-    return super.prepareCall(sql, resultSetType, resultSetConcurrency,
-                             resultSetHoldability);
+    try {
+      return super.prepareCall(sql, resultSetType, resultSetConcurrency,
+                               resultSetHoldability);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public PreparedStatement prepareStatement(String sql,
                                             int autoGeneratedKeys) throws SQLException {
     throwIfClosed();
-    return super.prepareStatement(sql, autoGeneratedKeys);
+    try {
+      return super.prepareStatement(sql, autoGeneratedKeys);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public PreparedStatement prepareStatement(String sql,
                                             int columnIndexes[]) throws SQLException {
     throwIfClosed();
-    return super.prepareStatement(sql, columnIndexes);
+    try {
+      return super.prepareStatement(sql, columnIndexes);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public PreparedStatement prepareStatement(String sql,
                                             String columnNames[]) throws SQLException {
     throwIfClosed();
-    return super.prepareStatement(sql, columnNames);
+    try {
+      return super.prepareStatement(sql, columnNames);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public Clob createClob() throws SQLException {
     throwIfClosed();
-    return super.createClob();
+    try {
+      return super.createClob();
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public Blob createBlob() throws SQLException {
     throwIfClosed();
-    return super.createBlob();
+    try {
+      return super.createBlob();
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public NClob createNClob() throws SQLException {
     throwIfClosed();
-    return super.createNClob();
+    try {
+      return super.createNClob();
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public SQLXML createSQLXML() throws SQLException {
     throwIfClosed();
-    return super.createSQLXML();
+    try {
+      return super.createSQLXML();
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public boolean isValid(int timeout) throws SQLException {
     throwIfClosed();
-    return super.isValid(timeout);
+    try {
+      return super.isValid(timeout);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
@@ -590,7 +660,14 @@ public void setClientInfo(String name, String value) throws SQLClientInfoExcepti
     } catch (AlreadyClosedSqlException e) {
       throw new SQLClientInfoException(e.getMessage(), null, e);
     }
-    super.setClientInfo(name,  value);
+    try {
+      super.setClientInfo(name,  value);
+    }
+    catch (UnsupportedOperationException e) {
+      SQLFeatureNotSupportedException intended =
+          new SQLFeatureNotSupportedException(e.getMessage(), e);
+      throw new SQLClientInfoException(e.getMessage(), null, intended);
+    }
   }
 
   @Override
@@ -600,31 +677,58 @@ public void setClientInfo(Properties properties) throws SQLClientInfoException {
     } catch (AlreadyClosedSqlException e) {
       throw new SQLClientInfoException(e.getMessage(), null, e);
     }
-    super.setClientInfo(properties);
+    try {
+      super.setClientInfo(properties);
+    }
+    catch (UnsupportedOperationException e) {
+      SQLFeatureNotSupportedException intended =
+          new SQLFeatureNotSupportedException(e.getMessage(), e);
+      throw new SQLClientInfoException(e.getMessage(), null, intended);
+    }
   }
 
   @Override
   public String getClientInfo(String name) throws SQLException {
     throwIfClosed();
-    return super.getClientInfo(name);
+    try {
+      return super.getClientInfo(name);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public Properties getClientInfo() throws SQLException {
     throwIfClosed();
-    return super.getClientInfo();
+    try {
+      return super.getClientInfo();
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
     throwIfClosed();
-    return super.createArrayOf(typeName, elements);
+    try {
+      return super.createArrayOf(typeName, elements);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
   public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
     throwIfClosed();
-    return super.createStruct(typeName, attributes);
+    try {
+      return super.createStruct(typeName, attributes);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
   @Override
@@ -648,7 +752,12 @@ public String getSchema() {
   @Override
   public void abort(Executor executor) throws SQLException {
     throwIfClosed();
-    super.abort(executor);
+    try {
+      super.abort(executor);
+    }
+    catch (UnsupportedOperationException e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
   }
 
 
@@ -692,6 +801,10 @@ void cleanup() {
     closeOrWarn(serviceSet, "Exception while closing service set.", logger);
   }
 
+  // TODO(DRILL-xxxx):  Eliminate this test-specific hack from production code.
+  // If we're not going to have tests themselves explicitly handle making names
+  // unique, then at least move this logic into a test base class, and have it
+  // go through DrillConnection.getClient().
   /**
    * Test only code to make JDBC tests run concurrently. If the property <i>drillJDBCUnitTests</i> is set to
    * <i>true</i> in connection properties:

exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillCursor.java

@@ -317,6 +317,7 @@ else if ( returnTrueForNextCallToNext ) {
       return true;
     }
     else {
+      accessors.clearLastColumnIndexedInRow();
       return nextRowInternally();
     }
   }