Return-Path: X-Original-To: apmail-drill-commits-archive@www.apache.org Delivered-To: apmail-drill-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id CC21618FA5 for ; Tue, 10 Nov 2015 21:49:37 +0000 (UTC) Received: (qmail 93249 invoked by uid 500); 10 Nov 2015 21:49:37 -0000 Delivered-To: apmail-drill-commits-archive@drill.apache.org Received: (qmail 93163 invoked by uid 500); 10 Nov 2015 21:49:37 -0000 Mailing-List: contact commits-help@drill.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: commits@drill.apache.org Delivered-To: mailing list commits@drill.apache.org Received: (qmail 93106 invoked by uid 99); 10 Nov 2015 21:49:37 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 10 Nov 2015 21:49:37 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id E56A0E56F2; Tue, 10 Nov 2015 21:49:36 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: hg@apache.org To: commits@drill.apache.org Date: Tue, 10 Nov 2015 21:49:37 -0000 Message-Id: In-Reply-To: <03cc9b58015843449c80bd8217f9acf2@git.apache.org> References: <03cc9b58015843449c80bd8217f9acf2@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [2/8] drill git commit: DRILL-2769: Fix most non-SQLException not-supported-yet exceptions. 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. Project: http://git-wip-us.apache.org/repos/asf/drill/repo Commit: http://git-wip-us.apache.org/repos/asf/drill/commit/e4f257b1 Tree: http://git-wip-us.apache.org/repos/asf/drill/tree/e4f257b1 Diff: http://git-wip-us.apache.org/repos/asf/drill/diff/e4f257b1 Branch: refs/heads/master Commit: e4f257b1f0200d3f1e977d37b61bdc53fa60533a Parents: daf816c Author: dbarclay Authored: Thu Aug 27 14:05:26 2015 -0700 Committer: Hanifi Gunes Committed: Mon Nov 9 12:17:02 2015 -0800 ---------------------------------------------------------------------- .../drill/jdbc/impl/DrillAccessorList.java | 50 +- .../drill/jdbc/impl/DrillConnectionImpl.java | 157 ++++- .../org/apache/drill/jdbc/impl/DrillCursor.java | 1 + .../jdbc/impl/DrillDatabaseMetaDataImpl.java | 132 +++- .../jdbc/impl/DrillPreparedStatementImpl.java | 189 ++++- .../drill/jdbc/impl/DrillResultSetImpl.java | 701 ++++++++++++++++--- .../jdbc/impl/DrillResultSetMetaDataImpl.java | 132 ++-- .../drill/jdbc/impl/DrillStatementImpl.java | 140 +++- ...69UnsupportedReportsUseSqlExceptionTest.java | 459 ++++++++++++ 9 files changed, 1712 insertions(+), 249 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/drill/blob/e4f257b1/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillAccessorList.java ---------------------------------------------------------------------- diff --git a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillAccessorList.java b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillAccessorList.java index 9284875..6f68415 100644 --- a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillAccessorList.java +++ b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillAccessorList.java @@ -26,15 +26,34 @@ import org.apache.drill.exec.record.RecordBatchLoader; 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{ - static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(DrillAccessorList.class); +class DrillAccessorList extends BasicList { + + @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 @@ class DrillAccessorList extends BasicList{ ); 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 http://git-wip-us.apache.org/repos/asf/drill/blob/e4f257b1/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillConnectionImpl.java ---------------------------------------------------------------------- diff --git a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillConnectionImpl.java b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillConnectionImpl.java index 1ff2693..fc7b667 100644 --- a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillConnectionImpl.java +++ b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillConnectionImpl.java @@ -406,13 +406,23 @@ class DrillConnectionImpl extends AvaticaConnection @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 @@ class DrillConnectionImpl extends AvaticaConnection 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> 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> 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 @@ class DrillConnectionImpl extends AvaticaConnection 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 @@ class DrillConnectionImpl extends AvaticaConnection } 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 @@ class DrillConnectionImpl extends AvaticaConnection } 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 @@ class DrillConnectionImpl extends AvaticaConnection @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 @@ class DrillConnectionImpl extends AvaticaConnection 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 drillJDBCUnitTests is set to * true in connection properties: http://git-wip-us.apache.org/repos/asf/drill/blob/e4f257b1/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillCursor.java ---------------------------------------------------------------------- diff --git a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillCursor.java b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillCursor.java index 51103dd..b36658b 100644 --- a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillCursor.java +++ b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillCursor.java @@ -317,6 +317,7 @@ class DrillCursor implements Cursor { return true; } else { + accessors.clearLastColumnIndexedInRow(); return nextRowInternally(); } } http://git-wip-us.apache.org/repos/asf/drill/blob/e4f257b1/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillDatabaseMetaDataImpl.java ---------------------------------------------------------------------- diff --git a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillDatabaseMetaDataImpl.java b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillDatabaseMetaDataImpl.java index 0855b01..a986749 100644 --- a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillDatabaseMetaDataImpl.java +++ b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillDatabaseMetaDataImpl.java @@ -22,6 +22,7 @@ import java.sql.DatabaseMetaData; import java.sql.ResultSet; import java.sql.RowIdLifetime; import java.sql.SQLException; +import java.sql.SQLFeatureNotSupportedException; import org.apache.drill.jdbc.AlreadyClosedSqlException; import org.apache.drill.jdbc.DrillDatabaseMetaData; @@ -122,7 +123,6 @@ class DrillDatabaseMetaDataImpl extends AvaticaDatabaseMetaData return false; } - @Override public String getDatabaseProductName() throws SQLException { throwIfClosed(); @@ -921,55 +921,154 @@ class DrillDatabaseMetaDataImpl extends AvaticaDatabaseMetaData @Override public boolean ownUpdatesAreVisible(int type) throws SQLException { throwIfClosed(); - return super.ownUpdatesAreVisible(type); + try { + return super.ownUpdatesAreVisible(type); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "ownUpdatesAreVisible(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override public boolean ownDeletesAreVisible(int type) throws SQLException { throwIfClosed(); - return super.ownDeletesAreVisible(type); + try { + return super.ownDeletesAreVisible(type); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "ownDeletesAreVisible(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override public boolean ownInsertsAreVisible(int type) throws SQLException { throwIfClosed(); - return super.ownInsertsAreVisible(type); + try { + return super.ownInsertsAreVisible(type); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "ownInsertsAreVisible(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override public boolean othersUpdatesAreVisible(int type) throws SQLException { throwIfClosed(); - return super.othersUpdatesAreVisible(type); + try { + return super.othersUpdatesAreVisible(type); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "othersUpdatesAreVisible(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override public boolean othersDeletesAreVisible(int type) throws SQLException { throwIfClosed(); - return super.othersDeletesAreVisible(type); + try { + return super.othersDeletesAreVisible(type); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "othersDeletesAreVisible(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override public boolean othersInsertsAreVisible(int type) throws SQLException { throwIfClosed(); - return super.othersInsertsAreVisible(type); + try { + return super.othersInsertsAreVisible(type); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "othersInsertsAreVisible(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override public boolean updatesAreDetected(int type) throws SQLException { throwIfClosed(); - return super.updatesAreDetected(type); + try { + return super.updatesAreDetected(type); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "updatesAreDetected(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override public boolean deletesAreDetected(int type) throws SQLException { throwIfClosed(); - return super.deletesAreDetected(type); + try { + return super.deletesAreDetected(type); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "deletesAreDetected(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override public boolean insertsAreDetected(int type) throws SQLException { throwIfClosed(); - return super.insertsAreDetected(type); + try { + return super.insertsAreDetected(type); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "insertsAreDetected(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override @@ -1042,7 +1141,18 @@ class DrillDatabaseMetaDataImpl extends AvaticaDatabaseMetaData @Override public boolean supportsResultSetHoldability(int holdability) throws SQLException { throwIfClosed(); - return super.supportsResultSetHoldability(holdability); + try { + return super.supportsResultSetHoldability(holdability); + } + catch (RuntimeException e) { + if ("todo: implement this method".equals(e.getMessage())) { + throw new SQLFeatureNotSupportedException( + "supportsResultSetHoldability(int) is not supported", e); + } + else { + throw new SQLException(e.getMessage(), e); + } + } } @Override http://git-wip-us.apache.org/repos/asf/drill/blob/e4f257b1/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillPreparedStatementImpl.java ---------------------------------------------------------------------- diff --git a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillPreparedStatementImpl.java b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillPreparedStatementImpl.java index f84e14e..f86edc6 100644 --- a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillPreparedStatementImpl.java +++ b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillPreparedStatementImpl.java @@ -106,13 +106,23 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public ResultSet executeQuery(String sql) throws SQLException { throwIfClosed(); - return super.executeQuery(sql); + try { + return super.executeQuery(sql); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int executeUpdate(String sql) throws SQLException { throwIfClosed(); - return super.executeUpdate(sql); + try { + return super.executeUpdate(sql); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } // No close() (it doesn't throw SQLException if already closed). @@ -120,13 +130,23 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public int getMaxFieldSize() throws SQLException { throwIfClosed(); - return super.getMaxFieldSize(); + try { + return super.getMaxFieldSize(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void setMaxFieldSize(int max) throws SQLException { throwIfClosed(); - super.setMaxFieldSize(max); + try { + super.setMaxFieldSize(max); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -150,7 +170,12 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public void setEscapeProcessing(boolean enable) throws SQLException { throwIfClosed(); - super.setEscapeProcessing(enable); + try { + super.setEscapeProcessing(enable); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -186,7 +211,12 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public void setCursorName(String name) throws SQLException { throwIfClosed(); - super.setCursorName(name); + try { + super.setCursorName(name); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -210,7 +240,12 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public boolean getMoreResults() throws SQLException { throwIfClosed(); - return super.getMoreResults(); + try { + return super.getMoreResults(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -252,85 +287,155 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public int getResultSetConcurrency() throws SQLException { throwIfClosed(); - return super.getResultSetConcurrency(); + try { + return super.getResultSetConcurrency(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int getResultSetType() throws SQLException { throwIfClosed(); - return super.getResultSetType(); + try { + return super.getResultSetType(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void addBatch(String sql) throws SQLException { throwIfClosed(); - super.addBatch(sql); + try { + super.addBatch(sql); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void clearBatch() throws SQLException { throwIfClosed(); - super.clearBatch(); + try { + super.clearBatch(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int[] executeBatch() throws SQLException { throwIfClosed(); - return super.executeBatch(); + try { + return super.executeBatch(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean getMoreResults(int current) throws SQLException { throwIfClosed(); - return super.getMoreResults(current); + try { + return super.getMoreResults(current); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public ResultSet getGeneratedKeys() throws SQLException { throwIfClosed(); - return super.getGeneratedKeys(); + try { + return super.getGeneratedKeys(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException { throwIfClosed(); - return super.executeUpdate(sql, autoGeneratedKeys); + try { + return super.executeUpdate(sql, autoGeneratedKeys); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int executeUpdate(String sql, int columnIndexes[]) throws SQLException { throwIfClosed(); - return super.executeUpdate(sql, columnIndexes); + try { + return super.executeUpdate(sql, columnIndexes); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int executeUpdate(String sql, String columnNames[]) throws SQLException { throwIfClosed(); - return super.executeUpdate(sql, columnNames); + try { + return super.executeUpdate(sql, columnNames); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean execute(String sql, int autoGeneratedKeys) throws SQLException { throwIfClosed(); - return super.execute(sql, autoGeneratedKeys); + try { + return super.execute(sql, autoGeneratedKeys); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean execute(String sql, int columnIndexes[]) throws SQLException { throwIfClosed(); - return super.execute(sql, columnIndexes); + try { + return super.execute(sql, columnIndexes); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean execute(String sql, String columnNames[]) throws SQLException { throwIfClosed(); - return super.execute(sql, columnNames); + try { + return super.execute(sql, columnNames); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int getResultSetHoldability() throws SQLException { throwIfClosed(); - return super.getResultSetHoldability(); + try { + return super.getResultSetHoldability(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -346,13 +451,23 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public void setPoolable(boolean poolable) throws SQLException { throwIfClosed(); - super.setPoolable(poolable); + try { + super.setPoolable(poolable); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean isPoolable() throws SQLException { throwIfClosed(); - return super.isPoolable(); + try { + return super.isPoolable(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -376,7 +491,12 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public int executeUpdate() throws SQLException { throwIfClosed(); - return super.executeUpdate(); + try { + return super.executeUpdate(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } // Covered by superclass methods' calls to getParameter(int): @@ -401,7 +521,12 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public void clearParameters() throws SQLException { throwIfClosed(); - super.clearParameters(); + try { + super.clearParameters(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } // Covered by superclass methods' calls to getParameter(int): @@ -411,13 +536,23 @@ abstract class DrillPreparedStatementImpl extends AvaticaPreparedStatement @Override public boolean execute() throws SQLException { throwIfClosed(); - return super.execute(); + try { + return super.execute(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void addBatch() throws SQLException { throwIfClosed(); - super.addBatch(); + try { + super.addBatch(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } // Covered by superclass methods' calls to getParameter(int): http://git-wip-us.apache.org/repos/asf/drill/blob/e4f257b1/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetImpl.java ---------------------------------------------------------------------- diff --git a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetImpl.java b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetImpl.java index 9f3e0f7..d7de677 100644 --- a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetImpl.java +++ b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetImpl.java @@ -31,6 +31,7 @@ import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.RowId; import java.sql.SQLException; +import java.sql.SQLFeatureNotSupportedException; import java.sql.SQLWarning; import java.sql.SQLXML; import java.sql.Time; @@ -403,7 +404,12 @@ class DrillResultSetImpl extends AvaticaResultSet implements DrillResultSet { @Override public String getCursorName() throws SQLException { throwIfClosed(); - return super.getCursorName(); + try { + return super.getCursorName(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } // (Not delegated.) @@ -484,31 +490,56 @@ class DrillResultSetImpl extends AvaticaResultSet implements DrillResultSet { @Override public boolean isLast() throws SQLException { throwIfClosed(); - return super.isLast(); + try { + return super.isLast(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void beforeFirst() throws SQLException { throwIfClosed(); - super.beforeFirst(); + try { + super.beforeFirst(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void afterLast() throws SQLException { throwIfClosed(); - super.afterLast(); + try { + super.afterLast(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean first() throws SQLException { throwIfClosed(); - return super.first(); + try { + return super.first(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean last() throws SQLException { throwIfClosed(); - return super.last(); + try { + return super.last(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -520,19 +551,34 @@ class DrillResultSetImpl extends AvaticaResultSet implements DrillResultSet { @Override public boolean absolute( int row ) throws SQLException { throwIfClosed(); - return super.absolute( row ); + try { + return super.absolute( row ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean relative( int rows ) throws SQLException { throwIfClosed(); - return super.relative( rows ); + try { + return super.relative( rows ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean previous() throws SQLException { throwIfClosed(); - return super.previous(); + try { + return super.previous(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } //--------------------------------------------------------------------- @@ -599,281 +645,506 @@ class DrillResultSetImpl extends AvaticaResultSet implements DrillResultSet { @Override public void updateNull( int columnIndex ) throws SQLException { throwIfClosed(); - super.updateNull( columnIndex ); + try { + super.updateNull( columnIndex ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBoolean( int columnIndex, boolean x ) throws SQLException { throwIfClosed(); - super.updateBoolean( columnIndex, x ); + try { + super.updateBoolean( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateByte( int columnIndex, byte x ) throws SQLException { throwIfClosed(); - super.updateByte( columnIndex, x ); + try { + super.updateByte( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateShort( int columnIndex, short x ) throws SQLException { throwIfClosed(); - super.updateShort( columnIndex, x ); + try { + super.updateShort( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateInt( int columnIndex, int x ) throws SQLException { throwIfClosed(); - super.updateInt( columnIndex, x ); + try { + super.updateInt( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateLong( int columnIndex, long x ) throws SQLException { throwIfClosed(); - super.updateLong( columnIndex, x ); + try { + super.updateLong( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateFloat( int columnIndex, float x ) throws SQLException { throwIfClosed(); - super.updateFloat( columnIndex, x ); + try { + super.updateFloat( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateDouble( int columnIndex, double x ) throws SQLException { throwIfClosed(); - super.updateDouble( columnIndex, x ); + try { + super.updateDouble( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBigDecimal( int columnIndex, BigDecimal x ) throws SQLException { throwIfClosed(); - super.updateBigDecimal( columnIndex, x ); + try { + super.updateBigDecimal( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateString( int columnIndex, String x ) throws SQLException { throwIfClosed(); - super.updateString( columnIndex, x ); + try { + super.updateString( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBytes( int columnIndex, byte[] x ) throws SQLException { throwIfClosed(); - super.updateBytes( columnIndex, x ); + try { + super.updateBytes( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateDate( int columnIndex, Date x ) throws SQLException { throwIfClosed(); - super.updateDate( columnIndex, x ); + try { + super.updateDate( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateTime( int columnIndex, Time x ) throws SQLException { throwIfClosed(); - super.updateTime( columnIndex, x ); + try { + super.updateTime( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateTimestamp( int columnIndex, Timestamp x ) throws SQLException { throwIfClosed(); - super.updateTimestamp( columnIndex, x ); + try { + super.updateTimestamp( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateAsciiStream( int columnIndex, InputStream x, int length ) throws SQLException { throwIfClosed(); - super.updateAsciiStream( columnIndex, x, length ); + try { + super.updateAsciiStream( columnIndex, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBinaryStream( int columnIndex, InputStream x, int length ) throws SQLException { throwIfClosed(); - super.updateBinaryStream( columnIndex, x, length ); + try { + super.updateBinaryStream( columnIndex, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateCharacterStream( int columnIndex, Reader x, int length ) throws SQLException { throwIfClosed(); - super.updateCharacterStream( columnIndex, x, length ); + try { + super.updateCharacterStream( columnIndex, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateObject( int columnIndex, Object x, int scaleOrLength ) throws SQLException { throwIfClosed(); - super.updateObject( columnIndex, x, scaleOrLength ); + try { + super.updateObject( columnIndex, x, scaleOrLength ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateObject( int columnIndex, Object x ) throws SQLException { throwIfClosed(); - super.updateObject( columnIndex, x ); + try { + super.updateObject( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNull( String columnLabel ) throws SQLException { throwIfClosed(); - super.updateNull( columnLabel ); + try { + super.updateNull( columnLabel ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBoolean( String columnLabel, boolean x ) throws SQLException { throwIfClosed(); - super.updateBoolean( columnLabel, x ); + try { + super.updateBoolean( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateByte( String columnLabel, byte x ) throws SQLException { throwIfClosed(); - super.updateByte( columnLabel, x ); + try { + super.updateByte( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateShort( String columnLabel, short x ) throws SQLException { throwIfClosed(); - super.updateShort( columnLabel, x ); + try { + super.updateShort( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateInt( String columnLabel, int x ) throws SQLException { throwIfClosed(); - super.updateInt( columnLabel, x ); + try { + super.updateInt( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateLong( String columnLabel, long x ) throws SQLException { throwIfClosed(); - super.updateLong( columnLabel, x ); + try { + super.updateLong( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateFloat( String columnLabel, float x ) throws SQLException { throwIfClosed(); - super.updateFloat( columnLabel, x ); + try { + super.updateFloat( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateDouble( String columnLabel, double x ) throws SQLException { throwIfClosed(); - super.updateDouble( columnLabel, x ); + try { + super.updateDouble( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBigDecimal( String columnLabel, BigDecimal x ) throws SQLException { throwIfClosed(); - super.updateBigDecimal( columnLabel, x ); + try { + super.updateBigDecimal( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateString( String columnLabel, String x ) throws SQLException { throwIfClosed(); - super.updateString( columnLabel, x ); + try { + super.updateString( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBytes( String columnLabel, byte[] x ) throws SQLException { throwIfClosed(); - super.updateBytes( columnLabel, x ); + try { + super.updateBytes( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateDate( String columnLabel, Date x ) throws SQLException { throwIfClosed(); - super.updateDate( columnLabel, x ); + try { + super.updateDate( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateTime( String columnLabel, Time x ) throws SQLException { throwIfClosed(); - super.updateTime( columnLabel, x ); + try { + super.updateTime( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateTimestamp( String columnLabel, Timestamp x ) throws SQLException { throwIfClosed(); - super.updateTimestamp( columnLabel, x ); + try { + super.updateTimestamp( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateAsciiStream( String columnLabel, InputStream x, int length ) throws SQLException { throwIfClosed(); - super.updateAsciiStream( columnLabel, x, length ); + try { + super.updateAsciiStream( columnLabel, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBinaryStream( String columnLabel, InputStream x, int length ) throws SQLException { throwIfClosed(); - super.updateBinaryStream( columnLabel, x, length ); + try { + super.updateBinaryStream( columnLabel, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateCharacterStream( String columnLabel, Reader reader, int length ) throws SQLException { throwIfClosed(); - super.updateCharacterStream( columnLabel, reader, length ); + try { + super.updateCharacterStream( columnLabel, reader, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateObject( String columnLabel, Object x, int scaleOrLength ) throws SQLException { throwIfClosed(); - super.updateObject( columnLabel, x, scaleOrLength ); + try { + super.updateObject( columnLabel, x, scaleOrLength ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateObject( String columnLabel, Object x ) throws SQLException { throwIfClosed(); - super.updateObject( columnLabel, x ); + try { + super.updateObject( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void insertRow() throws SQLException { throwIfClosed(); - super.insertRow(); + try { + super.insertRow(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateRow() throws SQLException { throwIfClosed(); - super.updateRow(); + try { + super.updateRow(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void deleteRow() throws SQLException { throwIfClosed(); - super.deleteRow(); + try { + super.deleteRow(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void refreshRow() throws SQLException { throwIfClosed(); - super.refreshRow(); + try { + super.refreshRow(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void cancelRowUpdates() throws SQLException { throwIfClosed(); - super.cancelRowUpdates(); + try { + super.cancelRowUpdates(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void moveToInsertRow() throws SQLException { throwIfClosed(); - super.moveToInsertRow(); + try { + super.moveToInsertRow(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void moveToCurrentRow() throws SQLException { throwIfClosed(); - super.moveToCurrentRow(); + try { + super.moveToCurrentRow(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -1006,74 +1277,134 @@ class DrillResultSetImpl extends AvaticaResultSet implements DrillResultSet { @Override public void updateRef( int columnIndex, Ref x ) throws SQLException { throwIfClosed(); - super.updateRef( columnIndex, x ); + try { + super.updateRef( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateRef( String columnLabel, Ref x ) throws SQLException { throwIfClosed(); - super.updateRef( columnLabel, x ); + try { + super.updateRef( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBlob( int columnIndex, Blob x ) throws SQLException { throwIfClosed(); - super.updateBlob( columnIndex, x ); + try { + super.updateBlob( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBlob( String columnLabel, Blob x ) throws SQLException { throwIfClosed(); - super.updateBlob( columnLabel, x ); + try { + super.updateBlob( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateClob( int columnIndex, Clob x ) throws SQLException { throwIfClosed(); - super.updateClob( columnIndex, x ); + try { + super.updateClob( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateClob( String columnLabel, Clob x ) throws SQLException { throwIfClosed(); - super.updateClob( columnLabel, x ); + try { + super.updateClob( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateArray( int columnIndex, Array x ) throws SQLException { throwIfClosed(); - super.updateArray( columnIndex, x ); + try { + super.updateArray( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateArray( String columnLabel, Array x ) throws SQLException { throwIfClosed(); - super.updateArray( columnLabel, x ); + try { + super.updateArray( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } //------------------------- JDBC 4.0 ----------------------------------- @Override public RowId getRowId( int columnIndex ) throws SQLException { throwIfClosed(); - return super.getRowId( columnIndex ); + try { + return super.getRowId( columnIndex ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public RowId getRowId( String columnLabel ) throws SQLException { throwIfClosed(); - return super.getRowId( columnLabel ); + try { + return super.getRowId( columnLabel ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateRowId( int columnIndex, RowId x ) throws SQLException { throwIfClosed(); - super.updateRowId( columnIndex, x ); + try { + super.updateRowId( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateRowId( String columnLabel, RowId x ) throws SQLException { throwIfClosed(); - super.updateRowId( columnLabel, x ); + try { + super.updateRowId( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -1091,26 +1422,46 @@ class DrillResultSetImpl extends AvaticaResultSet implements DrillResultSet { @Override public void updateNString( int columnIndex, String nString ) throws SQLException { throwIfClosed(); - super.updateNString( columnIndex, nString ); + try { + super.updateNString( columnIndex, nString ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNString( String columnLabel, String nString ) throws SQLException { throwIfClosed(); - super.updateNString( columnLabel, nString ); + try { + super.updateNString( columnLabel, nString ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNClob( int columnIndex, NClob nClob ) throws SQLException { throwIfClosed(); - super.updateNClob( columnIndex, nClob ); + try { + super.updateNClob( columnIndex, nClob ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNClob( String columnLabel, NClob nClob ) throws SQLException { throwIfClosed(); - super.updateNClob( columnLabel, nClob ); + try { + super.updateNClob( columnLabel, nClob ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -1141,14 +1492,24 @@ class DrillResultSetImpl extends AvaticaResultSet implements DrillResultSet { public void updateSQLXML( int columnIndex, SQLXML xmlObject ) throws SQLException { throwIfClosed(); - super.updateSQLXML( columnIndex, xmlObject ); + try { + super.updateSQLXML( columnIndex, xmlObject ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateSQLXML( String columnLabel, SQLXML xmlObject ) throws SQLException { throwIfClosed(); - super.updateSQLXML( columnLabel, xmlObject ); + try { + super.updateSQLXML( columnLabel, xmlObject ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -1179,98 +1540,168 @@ class DrillResultSetImpl extends AvaticaResultSet implements DrillResultSet { public void updateNCharacterStream( int columnIndex, Reader x, long length ) throws SQLException { throwIfClosed(); - super.updateNCharacterStream( columnIndex, x, length ); + try { + super.updateNCharacterStream( columnIndex, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNCharacterStream( String columnLabel, Reader reader, long length ) throws SQLException { throwIfClosed(); - super.updateNCharacterStream( columnLabel, reader, length ); + try { + super.updateNCharacterStream( columnLabel, reader, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateAsciiStream( int columnIndex, InputStream x, long length ) throws SQLException { throwIfClosed(); - super.updateAsciiStream( columnIndex, x, length ); + try { + super.updateAsciiStream( columnIndex, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBinaryStream( int columnIndex, InputStream x, long length ) throws SQLException { throwIfClosed(); - super.updateBinaryStream( columnIndex, x, length ); + try { + super.updateBinaryStream( columnIndex, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateCharacterStream( int columnIndex, Reader x, long length ) throws SQLException { throwIfClosed(); - super.updateCharacterStream( columnIndex, x, length ); + try { + super.updateCharacterStream( columnIndex, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateAsciiStream( String columnLabel, InputStream x, long length ) throws SQLException { throwIfClosed(); - super.updateAsciiStream( columnLabel, x, length ); + try { + super.updateAsciiStream( columnLabel, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBinaryStream( String columnLabel, InputStream x, long length ) throws SQLException { throwIfClosed(); - super.updateBinaryStream( columnLabel, x, length ); + try { + super.updateBinaryStream( columnLabel, x, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateCharacterStream( String columnLabel, Reader reader, long length ) throws SQLException { throwIfClosed(); - super.updateCharacterStream( columnLabel, reader, length ); + try { + super.updateCharacterStream( columnLabel, reader, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBlob( int columnIndex, InputStream inputStream, long length ) throws SQLException { throwIfClosed(); - super.updateBlob( columnIndex, inputStream, length ); + try { + super.updateBlob( columnIndex, inputStream, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBlob( String columnLabel, InputStream inputStream, long length ) throws SQLException { throwIfClosed(); - super.updateBlob( columnLabel, inputStream, length ); + try { + super.updateBlob( columnLabel, inputStream, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateClob( int columnIndex, Reader reader, long length ) throws SQLException { throwIfClosed(); - super.updateClob( columnIndex, reader, length ); + try { + super.updateClob( columnIndex, reader, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateClob( String columnLabel, Reader reader, long length ) throws SQLException { throwIfClosed(); - super.updateClob( columnLabel, reader, length ); + try { + super.updateClob( columnLabel, reader, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNClob( int columnIndex, Reader reader, long length ) throws SQLException { throwIfClosed(); - super.updateNClob( columnIndex, reader, length ); + try { + super.updateNClob( columnIndex, reader, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNClob( String columnLabel, Reader reader, long length ) throws SQLException { throwIfClosed(); - super.updateNClob( columnLabel, reader, length ); + try { + super.updateNClob( columnLabel, reader, length ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } //--- @@ -1278,94 +1709,164 @@ class DrillResultSetImpl extends AvaticaResultSet implements DrillResultSet { public void updateNCharacterStream( int columnIndex, Reader x ) throws SQLException { throwIfClosed(); - super.updateNCharacterStream( columnIndex, x ); + try { + super.updateNCharacterStream( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNCharacterStream( String columnLabel, Reader reader ) throws SQLException { throwIfClosed(); - super.updateNCharacterStream( columnLabel, reader ); + try { + super.updateNCharacterStream( columnLabel, reader ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateAsciiStream( int columnIndex, InputStream x ) throws SQLException { throwIfClosed(); - super.updateAsciiStream( columnIndex, x ); + try { + super.updateAsciiStream( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBinaryStream( int columnIndex, InputStream x ) throws SQLException { throwIfClosed(); - super.updateBinaryStream( columnIndex, x ); + try { + super.updateBinaryStream( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateCharacterStream( int columnIndex, Reader x ) throws SQLException { throwIfClosed(); - super.updateCharacterStream( columnIndex, x ); + try { + super.updateCharacterStream( columnIndex, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateAsciiStream( String columnLabel, InputStream x ) throws SQLException { throwIfClosed(); - super.updateAsciiStream( columnLabel, x ); + try { + super.updateAsciiStream( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBinaryStream( String columnLabel, InputStream x ) throws SQLException { throwIfClosed(); - super.updateBinaryStream( columnLabel, x ); + try { + super.updateBinaryStream( columnLabel, x ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateCharacterStream( String columnLabel, Reader reader ) throws SQLException { throwIfClosed(); - super.updateCharacterStream( columnLabel, reader ); + try { + super.updateCharacterStream( columnLabel, reader ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBlob( int columnIndex, InputStream inputStream ) throws SQLException { throwIfClosed(); - super.updateBlob( columnIndex, inputStream ); + try { + super.updateBlob( columnIndex, inputStream ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateBlob( String columnLabel, InputStream inputStream ) throws SQLException { throwIfClosed(); - super.updateBlob( columnLabel, inputStream ); + try { + super.updateBlob( columnLabel, inputStream ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateClob( int columnIndex, Reader reader ) throws SQLException { throwIfClosed(); - super.updateClob( columnIndex, reader ); + try { + super.updateClob( columnIndex, reader ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateClob( String columnLabel, Reader reader ) throws SQLException { throwIfClosed(); - super.updateClob( columnLabel, reader ); + try { + super.updateClob( columnLabel, reader ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNClob( int columnIndex, Reader reader ) throws SQLException { throwIfClosed(); - super.updateNClob( columnIndex, reader ); + try { + super.updateNClob( columnIndex, reader ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void updateNClob( String columnLabel, Reader reader ) throws SQLException { throwIfClosed(); - super.updateNClob( columnLabel, reader ); + try { + super.updateNClob( columnLabel, reader ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } //------------------------- JDBC 4.1 ----------------------------------- http://git-wip-us.apache.org/repos/asf/drill/blob/e4f257b1/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetMetaDataImpl.java ---------------------------------------------------------------------- diff --git a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetMetaDataImpl.java b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetMetaDataImpl.java index 4be93b4..79a3455 100644 --- a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetMetaDataImpl.java +++ b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetMetaDataImpl.java @@ -22,6 +22,7 @@ import java.sql.SQLException; import java.util.List; import org.apache.drill.jdbc.AlreadyClosedSqlException; +import org.apache.drill.jdbc.InvalidParameterSqlException; import net.hydromatic.avatica.AvaticaResultSetMetaData; import net.hydromatic.avatica.AvaticaStatement; @@ -56,6 +57,17 @@ public class DrillResultSetMetaDataImpl extends AvaticaResultSetMetaData { } } + private void throwIfClosedOrOutOfBounds(int columnNumber) + throws InvalidParameterSqlException, + SQLException { + throwIfClosed(); + if (1 > columnNumber || columnNumber > getColumnCount()) { + throw new InvalidParameterSqlException( + "Column number " + columnNumber + " out of range of from 1 through " + + getColumnCount() + " (column count)"); + } + } + // Note: Using dynamic proxies would reduce the quantity (450?) of method // overrides by eliminating those that exist solely to check whether the @@ -76,123 +88,123 @@ public class DrillResultSetMetaDataImpl extends AvaticaResultSetMetaData { } @Override - public boolean isAutoIncrement(int column) throws SQLException { - throwIfClosed(); - return super.isAutoIncrement(column); + public boolean isAutoIncrement(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.isAutoIncrement(columnNumber); } @Override - public boolean isCaseSensitive(int column) throws SQLException { - throwIfClosed(); - return super.isCaseSensitive(column); + public boolean isCaseSensitive(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.isCaseSensitive(columnNumber); } @Override - public boolean isSearchable(int column) throws SQLException { - throwIfClosed(); - return super.isSearchable(column); + public boolean isSearchable(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.isSearchable(columnNumber); } @Override - public boolean isCurrency(int column) throws SQLException { - throwIfClosed(); - return super.isCurrency(column); + public boolean isCurrency(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.isCurrency(columnNumber); } @Override - public int isNullable(int column) throws SQLException { - throwIfClosed(); - return super.isNullable(column); + public int isNullable(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.isNullable(columnNumber); } @Override - public boolean isSigned(int column) throws SQLException { - throwIfClosed(); - return super.isSigned(column); + public boolean isSigned(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.isSigned(columnNumber); } @Override - public int getColumnDisplaySize(int column) throws SQLException { - throwIfClosed(); - return super.getColumnDisplaySize(column); + public int getColumnDisplaySize(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getColumnDisplaySize(columnNumber); } @Override - public String getColumnLabel(int column) throws SQLException { - throwIfClosed(); - return super.getColumnLabel(column); + public String getColumnLabel(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getColumnLabel(columnNumber); } @Override - public String getColumnName(int column) throws SQLException { - throwIfClosed(); - return super.getColumnName(column); + public String getColumnName(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getColumnName(columnNumber); } @Override - public String getSchemaName(int column) throws SQLException { - throwIfClosed(); - return super.getSchemaName(column); + public String getSchemaName(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getSchemaName(columnNumber); } @Override - public int getPrecision(int column) throws SQLException { - throwIfClosed(); - return super.getPrecision(column); + public int getPrecision(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getPrecision(columnNumber); } @Override - public int getScale(int column) throws SQLException { - throwIfClosed(); - return super.getScale(column); + public int getScale(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getScale(columnNumber); } @Override - public String getTableName(int column) throws SQLException { - throwIfClosed(); - return super.getTableName(column); + public String getTableName(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getTableName(columnNumber); } @Override - public String getCatalogName(int column) throws SQLException { - throwIfClosed(); - return super.getCatalogName(column); + public String getCatalogName(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getCatalogName(columnNumber); } @Override - public int getColumnType(int column) throws SQLException { - throwIfClosed(); - return super.getColumnType(column); + public int getColumnType(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getColumnType(columnNumber); } @Override - public String getColumnTypeName(int column) throws SQLException { - throwIfClosed(); - return super.getColumnTypeName(column); + public String getColumnTypeName(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getColumnTypeName(columnNumber); } @Override - public boolean isReadOnly(int column) throws SQLException { - throwIfClosed(); - return super.isReadOnly(column); + public boolean isReadOnly(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.isReadOnly(columnNumber); } @Override - public boolean isWritable(int column) throws SQLException { - throwIfClosed(); - return super.isWritable(column); + public boolean isWritable(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.isWritable(columnNumber); } @Override - public boolean isDefinitelyWritable(int column) throws SQLException { - throwIfClosed(); - return super.isDefinitelyWritable(column); + public boolean isDefinitelyWritable(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.isDefinitelyWritable(columnNumber); } @Override - public String getColumnClassName(int column) throws SQLException { - throwIfClosed(); - return super.getColumnClassName(column); + public String getColumnClassName(int columnNumber) throws SQLException { + throwIfClosedOrOutOfBounds(columnNumber); + return super.getColumnClassName(columnNumber); } } http://git-wip-us.apache.org/repos/asf/drill/blob/e4f257b1/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillStatementImpl.java ---------------------------------------------------------------------- diff --git a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillStatementImpl.java b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillStatementImpl.java index 54b2709..5bdf5f8 100644 --- a/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillStatementImpl.java +++ b/exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillStatementImpl.java @@ -130,13 +130,23 @@ class DrillStatementImpl extends AvaticaStatement implements DrillStatement, @Override public int executeUpdate( String sql, int[] columnIndexes ) throws SQLException { throwIfClosed(); - return super.executeUpdate( sql, columnIndexes ); + try { + return super.executeUpdate( sql, columnIndexes ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int executeUpdate( String sql, String[] columnNames ) throws SQLException { throwIfClosed(); - return super.executeUpdate( sql, columnNames ); + try { + return super.executeUpdate( sql, columnNames ); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -195,13 +205,23 @@ class DrillStatementImpl extends AvaticaStatement implements DrillStatement, @Override public int getMaxFieldSize() throws SQLException { throwIfClosed(); - return super.getMaxFieldSize(); + try { + return super.getMaxFieldSize(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void setMaxFieldSize(int max) throws SQLException { throwIfClosed(); - super.setMaxFieldSize(max); + try { + super.setMaxFieldSize(max); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -225,7 +245,12 @@ class DrillStatementImpl extends AvaticaStatement implements DrillStatement, @Override public void setEscapeProcessing(boolean enable) throws SQLException { throwIfClosed(); - super.setEscapeProcessing(enable); + try { + super.setEscapeProcessing(enable); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -249,7 +274,12 @@ class DrillStatementImpl extends AvaticaStatement implements DrillStatement, @Override public void setCursorName(String name) throws SQLException { throwIfClosed(); - super.setCursorName(name); + try { + super.setCursorName(name); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -267,7 +297,12 @@ class DrillStatementImpl extends AvaticaStatement implements DrillStatement, @Override public boolean getMoreResults() throws SQLException { throwIfClosed(); - return super.getMoreResults(); + try { + return super.getMoreResults(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -309,13 +344,23 @@ class DrillStatementImpl extends AvaticaStatement implements DrillStatement, @Override public int getResultSetConcurrency() throws SQLException { throwIfClosed(); - return super.getResultSetConcurrency(); + try { + return super.getResultSetConcurrency(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int getResultSetType() throws SQLException { throwIfClosed(); - return super.getResultSetType(); + try { + return super.getResultSetType(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override @@ -332,67 +377,122 @@ class DrillStatementImpl extends AvaticaStatement implements DrillStatement, @Override public void clearBatch() throws SQLException { throwIfClosed(); - super.clearBatch(); + try { + super.clearBatch(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int[] executeBatch() throws SQLException { throwIfClosed(); - return super.executeBatch(); + try { + return super.executeBatch(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean getMoreResults(int current) throws SQLException { throwIfClosed(); - return super.getMoreResults(current); + try { + return super.getMoreResults(current); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public ResultSet getGeneratedKeys() throws SQLException { throwIfClosed(); - return super.getGeneratedKeys(); + try { + return super.getGeneratedKeys(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException { throwIfClosed(); - return super.executeUpdate(sql, autoGeneratedKeys); + try { + return super.executeUpdate(sql, autoGeneratedKeys); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean execute(String sql, int autoGeneratedKeys) throws SQLException { throwIfClosed(); - return super.execute(sql, autoGeneratedKeys); + try { + return super.execute(sql, autoGeneratedKeys); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean execute(String sql, int columnIndexes[]) throws SQLException { throwIfClosed(); - return super.execute(sql, columnIndexes); + try { + return super.execute(sql, columnIndexes); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean execute(String sql, String columnNames[]) throws SQLException { throwIfClosed(); - return super.execute(sql, columnNames); + try { + return super.execute(sql, columnNames); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public int getResultSetHoldability() throws SQLException { throwIfClosed(); - return super.getResultSetHoldability(); + try { + return super.getResultSetHoldability(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public void setPoolable(boolean poolable) throws SQLException { throwIfClosed(); - super.setPoolable(poolable); + try { + super.setPoolable(poolable); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override public boolean isPoolable() throws SQLException { throwIfClosed(); - return super.isPoolable(); + try { + return super.isPoolable(); + } + catch (UnsupportedOperationException e) { + throw new SQLFeatureNotSupportedException(e.getMessage(), e); + } } @Override