gparai commented on a change in pull request #1425: DRILL-6647: Update Calcite
version to 1.17.0
URL: https://github.com/apache/drill/pull/1425#discussion_r212096389
##########
File path:
exec/jdbc/src/main/java/org/apache/drill/jdbc/impl/DrillResultSetImpl.java
##########
@@ -162,1713 +160,1097 @@ public void close() {
super.close();
}
- @Override
- public boolean wasNull() throws SQLException {
- throwIfClosed();
- return super.wasNull();
- }
-
- // Methods for accessing results by column index
- @Override
- public String getString( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getString( columnIndex );
- }
-
- @Override
- public boolean getBoolean( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getBoolean( columnIndex );
- }
-
- @Override
- public byte getByte( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getByte( columnIndex );
- }
-
- @Override
- public short getShort( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getShort( columnIndex );
- }
-
- @Override
- public int getInt( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getInt( columnIndex );
- }
-
- @Override
- public long getLong( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getLong( columnIndex );
- }
-
- @Override
- public float getFloat( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getFloat( columnIndex );
- }
-
- @Override
- public double getDouble( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getDouble( columnIndex );
- }
-
- @Override
- public BigDecimal getBigDecimal( int columnIndex,
- int scale ) throws SQLException {
- throwIfClosed();
- return super.getBigDecimal( columnIndex, scale );
- }
-
- @Override
- public byte[] getBytes( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getBytes( columnIndex );
- }
-
- @Override
- public Date getDate( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getDate( columnIndex );
- }
-
- @Override
- public Time getTime( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getTime( columnIndex );
- }
-
- @Override
- public Timestamp getTimestamp( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getTimestamp( columnIndex );
- }
-
- @Override
- public InputStream getAsciiStream( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getAsciiStream( columnIndex );
- }
-
- @Override
- public InputStream getUnicodeStream( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getUnicodeStream( columnIndex );
- }
-
- @Override
- public InputStream getBinaryStream( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getBinaryStream( columnIndex );
- }
-
- // Methods for accessing results by column label
- @Override
- public String getString( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getString( columnLabel );
- }
-
- @Override
- public boolean getBoolean( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getBoolean( columnLabel );
- }
-
- @Override
- public byte getByte( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getByte( columnLabel );
- }
-
- @Override
- public short getShort( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getShort( columnLabel );
- }
-
- @Override
- public int getInt( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getInt( columnLabel );
- }
-
- @Override
- public long getLong( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getLong( columnLabel );
- }
-
- @Override
- public float getFloat( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getFloat( columnLabel );
- }
-
- @Override
- public double getDouble( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getDouble( columnLabel );
- }
-
- @Override
- public BigDecimal getBigDecimal( String columnLabel,
- int scale ) throws SQLException {
- throwIfClosed();
- return super.getBigDecimal( columnLabel, scale );
- }
-
- @Override
- public byte[] getBytes( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getBytes( columnLabel );
- }
-
- @Override
- public Date getDate( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getDate( columnLabel );
- }
-
- @Override
- public Time getTime( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getTime( columnLabel );
- }
-
- @Override
- public Timestamp getTimestamp( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getTimestamp( columnLabel );
- }
-
- @Override
- public InputStream getAsciiStream( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getAsciiStream( columnLabel );
- }
-
- @Override
- public InputStream getUnicodeStream( String columnLabel ) throws
SQLException {
- throwIfClosed();
- return super.getUnicodeStream( columnLabel );
- }
-
- @Override
- public InputStream getBinaryStream( String columnLabel ) throws SQLException
{
- throwIfClosed();
- return super.getBinaryStream( columnLabel );
- }
-
- // Advanced features:
- @Override
- public SQLWarning getWarnings() throws SQLException {
- throwIfClosed();
- return super.getWarnings();
- }
-
- @Override
- public void clearWarnings() throws SQLException {
- throwIfClosed();
- super.clearWarnings();
- }
-
@Override
public String getCursorName() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
return super.getCursorName();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
- // (Not delegated.)
- @Override
- public ResultSetMetaData getMetaData() throws SQLException {
- throwIfClosed();
- return super.getMetaData();
- }
-
@Override
public Object getObject( int columnIndex ) throws SQLException {
- throwIfClosed();
+ checkOpen();
- final Cursor.Accessor accessor;
+ Cursor.Accessor accessor;
try {
accessor = accessorList.get(columnIndex - 1);
} catch (RuntimeException e) {
throw new SQLException(e);
}
- final ColumnMetaData metaData = columnMetaDataList.get(columnIndex - 1);
+ ColumnMetaData metaData = columnMetaDataList.get(columnIndex - 1);
// Drill returns a float (4bytes) for a SQL Float whereas Calcite would
return a double (8bytes)
int typeId = (metaData.type.id != Types.FLOAT) ? metaData.type.id :
Types.REAL;
return AvaticaSite.get(accessor, typeId, localCalendar);
}
- @Override
- public Object getObject( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getObject( columnLabel );
- }
-
- //----------------------------------------------------------------
- @Override
- public int findColumn( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.findColumn( columnLabel );
- }
-
- //--------------------------JDBC 2.0-----------------------------------
- //---------------------------------------------------------------------
- // Getters and Setters
- //---------------------------------------------------------------------
- @Override
- public Reader getCharacterStream( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getCharacterStream( columnIndex );
- }
-
- @Override
- public Reader getCharacterStream( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getCharacterStream( columnLabel );
- }
-
- @Override
- public BigDecimal getBigDecimal( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getBigDecimal( columnIndex );
- }
-
- @Override
- public BigDecimal getBigDecimal( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getBigDecimal( columnLabel );
- }
-
//---------------------------------------------------------------------
// Traversal/Positioning
//---------------------------------------------------------------------
- @Override
- public boolean isBeforeFirst() throws SQLException {
- throwIfClosed();
- return super.isBeforeFirst();
- }
-
- @Override
- public boolean isAfterLast() throws SQLException {
- throwIfClosed();
- return super.isAfterLast();
- }
-
- @Override
- public boolean isFirst() throws SQLException {
- throwIfClosed();
- return super.isFirst();
- }
-
@Override
public boolean isLast() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
return super.isLast();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public void beforeFirst() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
super.beforeFirst();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public void afterLast() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
super.afterLast();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public boolean first() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
return super.first();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public boolean last() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
return super.last();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public int getRow() throws SQLException {
- throwIfClosed();
- // Map Avatica's erroneous zero-based row numbers to 1-based, and return 0
- // after end, per JDBC:
- return isAfterLast() ? 0 : 1 + super.getRow();
- }
-
- @Override
- public boolean absolute( int row ) throws SQLException {
- throwIfClosed();
+ public boolean absolute(int row) throws SQLException {
+ checkOpen();
try {
- return super.absolute( row );
- }
- catch (UnsupportedOperationException e) {
+ return super.absolute(row);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public boolean relative( int rows ) throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
return super.relative( rows );
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public boolean previous() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
return super.previous();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
- //---------------------------------------------------------------------
- // Properties
- //---------------------------------------------------------------------
-
- @Override
- public void setFetchDirection( int direction ) throws SQLException {
- throwIfClosed();
- super.setFetchDirection( direction );
- }
-
- @Override
- public int getFetchDirection() throws SQLException {
- throwIfClosed();
- return super.getFetchDirection();
- }
-
- @Override
- public void setFetchSize( int rows ) throws SQLException {
- throwIfClosed();
- super.setFetchSize( rows );
- }
-
- @Override
- public int getFetchSize() throws SQLException {
- throwIfClosed();
- return super.getFetchSize();
- }
-
- @Override
- public int getType() throws SQLException {
- throwIfClosed();
- return super.getType();
- }
-
- @Override
- public int getConcurrency() throws SQLException {
- throwIfClosed();
- return super.getConcurrency();
- }
-
//---------------------------------------------------------------------
// Updates
//---------------------------------------------------------------------
@Override
- public boolean rowUpdated() throws SQLException {
- throwIfClosed();
- return super.rowUpdated();
- }
-
- @Override
- public boolean rowInserted() throws SQLException {
- throwIfClosed();
- return super.rowInserted();
- }
-
- @Override
- public boolean rowDeleted() throws SQLException {
- throwIfClosed();
- return super.rowDeleted();
- }
-
- @Override
- public void updateNull( int columnIndex ) throws SQLException {
- throwIfClosed();
+ public void updateNull(int columnIndex) throws SQLException {
+ checkOpen();
try {
super.updateNull( columnIndex );
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBoolean( int columnIndex, boolean x ) throws SQLException {
- throwIfClosed();
+ public void updateBoolean(int columnIndex, boolean x) throws SQLException {
+ checkOpen();
try {
- super.updateBoolean( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBoolean(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateByte( int columnIndex, byte x ) throws SQLException {
- throwIfClosed();
+ public void updateByte(int columnIndex, byte x) throws SQLException {
+ checkOpen();
try {
super.updateByte( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateShort( int columnIndex, short x ) throws SQLException {
- throwIfClosed();
+ public void updateShort(int columnIndex, short x) throws SQLException {
+ checkOpen();
try {
- super.updateShort( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateShort(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateInt( int columnIndex, int x ) throws SQLException {
- throwIfClosed();
+ public void updateInt(int columnIndex, int x) throws SQLException {
+ checkOpen();
try {
- super.updateInt( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateInt(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateLong( int columnIndex, long x ) throws SQLException {
- throwIfClosed();
+ public void updateLong(int columnIndex, long x) throws SQLException {
+ checkOpen();
try {
- super.updateLong( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateLong(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateFloat( int columnIndex, float x ) throws SQLException {
- throwIfClosed();
+ public void updateFloat(int columnIndex, float x) throws SQLException {
+ checkOpen();
try {
- super.updateFloat( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateFloat(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateDouble( int columnIndex, double x ) throws SQLException {
- throwIfClosed();
+ public void updateDouble(int columnIndex, double x) throws SQLException {
+ checkOpen();
try {
- super.updateDouble( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateDouble(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBigDecimal( int columnIndex,
- BigDecimal x ) throws SQLException {
- throwIfClosed();
+ public void updateBigDecimal(int columnIndex, BigDecimal x) throws
SQLException {
+ checkOpen();
try {
- super.updateBigDecimal( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBigDecimal(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateString( int columnIndex, String x ) throws SQLException {
- throwIfClosed();
+ public void updateString(int columnIndex, String x) throws SQLException {
+ checkOpen();
try {
- super.updateString( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateString(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBytes( int columnIndex, byte[] x ) throws SQLException {
- throwIfClosed();
+ public void updateBytes(int columnIndex, byte[] x) throws SQLException {
+ checkOpen();
try {
- super.updateBytes( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBytes(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateDate( int columnIndex, Date x ) throws SQLException {
- throwIfClosed();
+ public void updateDate(int columnIndex, Date x) throws SQLException {
+ checkOpen();
try {
- super.updateDate( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateDate(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateTime( int columnIndex, Time x ) throws SQLException {
- throwIfClosed();
+ public void updateTime(int columnIndex, Time x) throws SQLException {
+ checkOpen();
try {
- super.updateTime( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateTime(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateTimestamp( int columnIndex, Timestamp x ) throws
SQLException {
- throwIfClosed();
+ public void updateTimestamp(int columnIndex, Timestamp x) throws
SQLException {
+ checkOpen();
try {
- super.updateTimestamp( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateAsciiStream(int columnIndex, InputStream x, int length)
throws SQLException {
+ checkOpen();
try {
- super.updateAsciiStream( columnIndex, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateBinaryStream(int columnIndex, InputStream x,
+ int length) throws SQLException {
+ checkOpen();
try {
- super.updateBinaryStream( columnIndex, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateCharacterStream(int columnIndex, Reader x,
+ int length) throws SQLException {
+ checkOpen();
try {
- super.updateCharacterStream( columnIndex, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateObject(int columnIndex, Object x,
+ int scaleOrLength) throws SQLException {
+ checkOpen();
try {
- super.updateObject( columnIndex, x, scaleOrLength );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateObject(int columnIndex, Object x) throws SQLException {
+ checkOpen();
try {
- super.updateObject( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateObject(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateNull( String columnLabel ) throws SQLException {
- throwIfClosed();
+ public void updateObject(int columnIndex, Object x, SQLType targetSqlType,
int scaleOrLength) throws SQLException {
+ checkOpen();
+ super.updateObject(columnIndex, x, targetSqlType, scaleOrLength);
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x, SQLType
targetSqlType, int scaleOrLength) throws SQLException {
+ checkOpen();
+ super.updateObject(columnLabel, x, targetSqlType, scaleOrLength);
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x, SQLType targetSqlType)
throws SQLException {
+ checkOpen();
+ super.updateObject(columnIndex, x, targetSqlType);
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x, SQLType
targetSqlType) throws SQLException {
+ checkOpen();
+ super.updateObject(columnLabel, x, targetSqlType);
+ }
+
+ @Override
+ public void updateNull(String columnLabel) throws SQLException {
+ checkOpen();
try {
- super.updateNull( columnLabel );
- }
- catch (UnsupportedOperationException e) {
+ super.updateNull(columnLabel);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBoolean( String columnLabel, boolean x ) throws
SQLException {
- throwIfClosed();
+ public void updateBoolean(String columnLabel, boolean x) throws SQLException
{
+ checkOpen();
try {
- super.updateBoolean( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBoolean(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateByte( String columnLabel, byte x ) throws SQLException {
- throwIfClosed();
+ public void updateByte(String columnLabel, byte x) throws SQLException {
+ checkOpen();
try {
- super.updateByte( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateByte(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateShort( String columnLabel, short x ) throws SQLException {
- throwIfClosed();
+ public void updateShort(String columnLabel, short x) throws SQLException {
+ checkOpen();
try {
- super.updateShort( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateShort(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateInt( String columnLabel, int x ) throws SQLException {
- throwIfClosed();
+ public void updateInt(String columnLabel, int x) throws SQLException {
+ checkOpen();
try {
- super.updateInt( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateInt(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateLong( String columnLabel, long x ) throws SQLException {
- throwIfClosed();
+ public void updateLong(String columnLabel, long x) throws SQLException {
+ checkOpen();
try {
- super.updateLong( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateLong(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateFloat( String columnLabel, float x ) throws SQLException {
- throwIfClosed();
+ public void updateFloat(String columnLabel, float x) throws SQLException {
+ checkOpen();
try {
- super.updateFloat( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateFloat(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateDouble( String columnLabel, double x ) throws SQLException
{
- throwIfClosed();
+ public void updateDouble(String columnLabel, double x) throws SQLException {
+ checkOpen();
try {
- super.updateDouble( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateDouble(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBigDecimal( String columnLabel,
- BigDecimal x ) throws SQLException {
- throwIfClosed();
+ public void updateBigDecimal(String columnLabel,
+ BigDecimal x) throws SQLException {
+ checkOpen();
try {
- super.updateBigDecimal( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBigDecimal(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateString( String columnLabel, String x ) throws SQLException
{
- throwIfClosed();
+ public void updateString(String columnLabel, String x) throws SQLException {
+ checkOpen();
try {
- super.updateString( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateString(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBytes( String columnLabel, byte[] x ) throws SQLException {
- throwIfClosed();
+ public void updateBytes(String columnLabel, byte[] x) throws SQLException {
+ checkOpen();
try {
- super.updateBytes( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBytes(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateDate( String columnLabel, Date x ) throws SQLException {
- throwIfClosed();
+ public void updateDate(String columnLabel, Date x) throws SQLException {
+ checkOpen();
try {
- super.updateDate( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateDate(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateTime( String columnLabel, Time x ) throws SQLException {
- throwIfClosed();
+ public void updateTime(String columnLabel, Time x) throws SQLException {
+ checkOpen();
try {
- super.updateTime( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateTime(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateTimestamp( String columnLabel, Timestamp x ) throws
SQLException {
- throwIfClosed();
+ public void updateTimestamp(String columnLabel, Timestamp x) throws
SQLException {
+ checkOpen();
try {
- super.updateTimestamp( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateAsciiStream(String columnLabel, InputStream x,
+ int length) throws SQLException {
+ checkOpen();
try {
- super.updateAsciiStream( columnLabel, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateBinaryStream(String columnLabel, InputStream x,
+ int length) throws SQLException {
+ checkOpen();
try {
- super.updateBinaryStream( columnLabel, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateCharacterStream(String columnLabel, Reader reader,
+ int length) throws SQLException {
+ checkOpen();
try {
- super.updateCharacterStream( columnLabel, reader, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateObject(String columnLabel, Object x,
+ int scaleOrLength) throws SQLException {
+ checkOpen();
try {
- super.updateObject( columnLabel, x, scaleOrLength );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateObject(String columnLabel, Object x) throws SQLException {
+ checkOpen();
try {
- super.updateObject( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateObject(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public void insertRow() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
super.insertRow();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public void updateRow() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
super.updateRow();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public void deleteRow() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
super.deleteRow();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public void refreshRow() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
super.refreshRow();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public void cancelRowUpdates() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
super.cancelRowUpdates();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public void moveToInsertRow() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
super.moveToInsertRow();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
public void moveToCurrentRow() throws SQLException {
- throwIfClosed();
+ checkOpen();
try {
super.moveToCurrentRow();
- }
- catch (UnsupportedOperationException e) {
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
- @Override
- public AvaticaStatement getStatement() throws SQLException {
- throwIfClosed();
- return super.getStatement();
- }
-
- @Override
- public Object getObject( int columnIndex,
- Map<String, Class<?>> map ) throws SQLException {
- throwIfClosed();
- return super.getObject( columnIndex, map );
- }
-
- @Override
- public Ref getRef( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getRef( columnIndex );
- }
-
- @Override
- public Blob getBlob( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getBlob( columnIndex );
- }
-
- @Override
- public Clob getClob( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getClob( columnIndex );
- }
-
- @Override
- public Array getArray( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getArray( columnIndex );
- }
-
- @Override
- public Object getObject( String columnLabel,
- Map<String,Class<?>> map ) throws SQLException {
- throwIfClosed();
- return super.getObject( columnLabel, map );
- }
-
- @Override
- public Ref getRef( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getRef( columnLabel );
- }
-
- @Override
- public Blob getBlob( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getBlob( columnLabel );
- }
-
- @Override
- public Clob getClob( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getClob( columnLabel );
- }
-
- @Override
- public Array getArray( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getArray( columnLabel );
- }
-
- @Override
- public Date getDate( int columnIndex, Calendar cal ) throws SQLException {
- throwIfClosed();
- return super.getDate( columnIndex, cal );
- }
-
- @Override
- public Date getDate( String columnLabel, Calendar cal ) throws SQLException {
- throwIfClosed();
- return super.getDate( columnLabel, cal );
- }
-
- @Override
- public Time getTime( int columnIndex, Calendar cal ) throws SQLException {
- throwIfClosed();
- return super.getTime( columnIndex, cal );
- }
-
- @Override
- public Time getTime( String columnLabel, Calendar cal ) throws SQLException {
- throwIfClosed();
- return super.getTime( columnLabel, cal );
- }
-
- @Override
- public Timestamp getTimestamp( int columnIndex, Calendar cal ) throws
SQLException {
- throwIfClosed();
- return super.getTimestamp( columnIndex, cal );
- }
-
- @Override
- public Timestamp getTimestamp( String columnLabel,
- Calendar cal ) throws SQLException {
- throwIfClosed();
- return super.getTimestamp( columnLabel, cal );
- }
-
//-------------------------- JDBC 3.0
----------------------------------------
@Override
- public URL getURL( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getURL( columnIndex );
- }
-
- @Override
- public URL getURL( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getURL( columnLabel );
- }
-
- @Override
- public void updateRef( int columnIndex, Ref x ) throws SQLException {
- throwIfClosed();
+ public void updateRef(int columnIndex, Ref x) throws SQLException {
+ checkOpen();
try {
- super.updateRef( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateRef(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateRef( String columnLabel, Ref x ) throws SQLException {
- throwIfClosed();
+ public void updateRef(String columnLabel, Ref x) throws SQLException {
+ checkOpen();
try {
- super.updateRef( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateRef(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBlob( int columnIndex, Blob x ) throws SQLException {
- throwIfClosed();
+ public void updateBlob(int columnIndex, Blob x) throws SQLException {
+ checkOpen();
try {
- super.updateBlob( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBlob(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBlob( String columnLabel, Blob x ) throws SQLException {
- throwIfClosed();
+ public void updateBlob(String columnLabel, Blob x) throws SQLException {
+ checkOpen();
try {
- super.updateBlob( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBlob(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateClob( int columnIndex, Clob x ) throws SQLException {
- throwIfClosed();
+ public void updateClob(int columnIndex, Clob x) throws SQLException {
+ checkOpen();
try {
- super.updateClob( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateClob(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateClob( String columnLabel, Clob x ) throws SQLException {
- throwIfClosed();
+ public void updateClob(String columnLabel, Clob x) throws SQLException {
+ checkOpen();
try {
- super.updateClob( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateClob(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateArray( int columnIndex, Array x ) throws SQLException {
- throwIfClosed();
+ public void updateArray(int columnIndex, Array x) throws SQLException {
+ checkOpen();
try {
- super.updateArray( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateArray(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateArray( String columnLabel, Array x ) throws SQLException {
- throwIfClosed();
+ public void updateArray(String columnLabel, Array x) throws SQLException {
+ checkOpen();
try {
- super.updateArray( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public RowId getRowId(int columnIndex) throws SQLException {
+ checkOpen();
try {
- return super.getRowId( columnIndex );
- }
- catch (UnsupportedOperationException e) {
+ return super.getRowId(columnIndex);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public RowId getRowId( String columnLabel ) throws SQLException {
- throwIfClosed();
+ public RowId getRowId(String columnLabel) throws SQLException {
+ checkOpen();
try {
- return super.getRowId( columnLabel );
- }
- catch (UnsupportedOperationException e) {
+ return super.getRowId(columnLabel);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateRowId( int columnIndex, RowId x ) throws SQLException {
- throwIfClosed();
+ public void updateRowId(int columnIndex, RowId x) throws SQLException {
+ checkOpen();
try {
- super.updateRowId( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateRowId(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateRowId( String columnLabel, RowId x ) throws SQLException {
- throwIfClosed();
+ public void updateRowId(String columnLabel, RowId x) throws SQLException {
+ checkOpen();
try {
- super.updateRowId( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateRowId(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public int getHoldability() throws SQLException {
- throwIfClosed();
- return super.getHoldability();
- }
-
- @Override
- public boolean isClosed() throws SQLException {
- // Note: No already-closed exception for isClosed().
- return super.isClosed();
- }
-
- @Override
- public void updateNString( int columnIndex, String nString ) throws
SQLException {
- throwIfClosed();
+ public void updateNString(int columnIndex, String nString) throws
SQLException {
+ checkOpen();
try {
- super.updateNString( columnIndex, nString );
- }
- catch (UnsupportedOperationException e) {
+ super.updateNString(columnIndex, nString);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateNString( String columnLabel,
- String nString ) throws SQLException {
- throwIfClosed();
+ public void updateNString(String columnLabel,
+ String nString) throws SQLException {
+ checkOpen();
try {
- super.updateNString( columnLabel, nString );
- }
- catch (UnsupportedOperationException e) {
+ super.updateNString(columnLabel, nString);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateNClob( int columnIndex, NClob nClob ) throws SQLException {
- throwIfClosed();
+ public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
+ checkOpen();
try {
- super.updateNClob( columnIndex, nClob );
- }
- catch (UnsupportedOperationException e) {
+ super.updateNClob(columnIndex, nClob);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateNClob( String columnLabel, NClob nClob ) throws
SQLException {
- throwIfClosed();
+ public void updateNClob(String columnLabel, NClob nClob) throws SQLException
{
+ checkOpen();
try {
- super.updateNClob( columnLabel, nClob );
- }
- catch (UnsupportedOperationException e) {
+ super.updateNClob(columnLabel, nClob);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public NClob getNClob( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getNClob( columnIndex );
- }
-
- @Override
- public NClob getNClob( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getNClob( columnLabel );
- }
-
- @Override
- public SQLXML getSQLXML( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getSQLXML( columnIndex );
- }
-
- @Override
- public SQLXML getSQLXML( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getSQLXML( columnLabel );
- }
-
- @Override
- public void updateSQLXML( int columnIndex,
- SQLXML xmlObject ) throws SQLException {
- throwIfClosed();
+ public void updateSQLXML(int columnIndex,
+ SQLXML xmlObject) throws SQLException {
+ checkOpen();
try {
- super.updateSQLXML( columnIndex, xmlObject );
- }
- catch (UnsupportedOperationException e) {
+ super.updateSQLXML(columnIndex, xmlObject);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateSQLXML( String columnLabel,
- SQLXML xmlObject ) throws SQLException {
- throwIfClosed();
+ public void updateSQLXML(String columnLabel,
+ SQLXML xmlObject) throws SQLException {
+ checkOpen();
try {
- super.updateSQLXML( columnLabel, xmlObject );
- }
- catch (UnsupportedOperationException e) {
+ super.updateSQLXML(columnLabel, xmlObject);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public String getNString( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getNString( columnIndex );
- }
-
- @Override
- public String getNString( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getNString( columnLabel );
- }
-
- @Override
- public Reader getNCharacterStream( int columnIndex ) throws SQLException {
- throwIfClosed();
- return super.getNCharacterStream( columnIndex );
- }
-
- @Override
- public Reader getNCharacterStream( String columnLabel ) throws SQLException {
- throwIfClosed();
- return super.getNCharacterStream( columnLabel );
- }
-
- @Override
- public void updateNCharacterStream( int columnIndex, Reader x,
- long length ) throws SQLException {
- throwIfClosed();
+ public void updateNCharacterStream(int columnIndex, Reader x,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateNCharacterStream( columnIndex, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateNCharacterStream(String columnLabel, Reader reader,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateNCharacterStream( columnLabel, reader, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateAsciiStream(int columnIndex, InputStream x,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateAsciiStream( columnIndex, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateBinaryStream(int columnIndex, InputStream x,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateBinaryStream( columnIndex, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateCharacterStream(int columnIndex, Reader x,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateCharacterStream( columnIndex, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateAsciiStream(String columnLabel, InputStream x,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateAsciiStream( columnLabel, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateBinaryStream(String columnLabel, InputStream x,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateBinaryStream( columnLabel, x, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateCharacterStream(String columnLabel, Reader reader,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateCharacterStream( columnLabel, reader, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateBlob(int columnIndex, InputStream inputStream,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateBlob( columnIndex, inputStream, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateBlob(String columnLabel, InputStream inputStream,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateBlob( columnLabel, inputStream, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateClob(int columnIndex, Reader reader,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateClob( columnIndex, reader, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateClob(String columnLabel, Reader reader,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateClob( columnLabel, reader, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateNClob(int columnIndex, Reader reader,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateNClob( columnIndex, reader, length );
- }
- catch (UnsupportedOperationException e) {
+ 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();
+ public void updateNClob(String columnLabel, Reader reader,
+ long length) throws SQLException {
+ checkOpen();
try {
- super.updateNClob( columnLabel, reader, length );
- }
- catch (UnsupportedOperationException e) {
+ super.updateNClob(columnLabel, reader, length);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
//---
@Override
- public void updateNCharacterStream( int columnIndex,
- Reader x ) throws SQLException {
- throwIfClosed();
+ public void updateNCharacterStream(int columnIndex,
+ Reader x) throws SQLException {
+ checkOpen();
try {
- super.updateNCharacterStream( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateNCharacterStream(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateNCharacterStream( String columnLabel,
- Reader reader ) throws SQLException {
- throwIfClosed();
+ public void updateNCharacterStream(String columnLabel,
+ Reader reader) throws SQLException {
+ checkOpen();
try {
- super.updateNCharacterStream( columnLabel, reader );
- }
- catch (UnsupportedOperationException e) {
+ super.updateNCharacterStream(columnLabel, reader);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateAsciiStream( int columnIndex,
- InputStream x ) throws SQLException {
- throwIfClosed();
+ public void updateAsciiStream(int columnIndex,
+ InputStream x) throws SQLException {
+ checkOpen();
try {
- super.updateAsciiStream( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateAsciiStream(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBinaryStream( int columnIndex,
- InputStream x ) throws SQLException {
- throwIfClosed();
+ public void updateBinaryStream(int columnIndex,
+ InputStream x) throws SQLException {
+ checkOpen();
try {
- super.updateBinaryStream( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBinaryStream(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateCharacterStream( int columnIndex,
- Reader x ) throws SQLException {
- throwIfClosed();
+ public void updateCharacterStream(int columnIndex,
+ Reader x) throws SQLException {
+ checkOpen();
try {
- super.updateCharacterStream( columnIndex, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateCharacterStream(columnIndex, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateAsciiStream( String columnLabel,
- InputStream x ) throws SQLException {
- throwIfClosed();
+ public void updateAsciiStream(String columnLabel,
+ InputStream x) throws SQLException {
+ checkOpen();
try {
- super.updateAsciiStream( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateAsciiStream(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBinaryStream( String columnLabel,
- InputStream x ) throws SQLException {
- throwIfClosed();
+ public void updateBinaryStream(String columnLabel,
+ InputStream x) throws SQLException {
+ checkOpen();
try {
- super.updateBinaryStream( columnLabel, x );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBinaryStream(columnLabel, x);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateCharacterStream( String columnLabel,
- Reader reader ) throws SQLException {
- throwIfClosed();
+ public void updateCharacterStream(String columnLabel,
+ Reader reader) throws SQLException {
+ checkOpen();
try {
- super.updateCharacterStream( columnLabel, reader );
- }
- catch (UnsupportedOperationException e) {
+ super.updateCharacterStream(columnLabel, reader);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBlob( int columnIndex,
- InputStream inputStream ) throws SQLException {
- throwIfClosed();
+ public void updateBlob(int columnIndex,
+ InputStream inputStream) throws SQLException {
+ checkOpen();
try {
- super.updateBlob( columnIndex, inputStream );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBlob(columnIndex, inputStream);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateBlob( String columnLabel,
- InputStream inputStream ) throws SQLException {
- throwIfClosed();
+ public void updateBlob(String columnLabel,
+ InputStream inputStream) throws SQLException {
+ checkOpen();
try {
- super.updateBlob( columnLabel, inputStream );
- }
- catch (UnsupportedOperationException e) {
+ super.updateBlob(columnLabel, inputStream);
+ } catch (UnsupportedOperationException e) {
throw new SQLFeatureNotSupportedException(e.getMessage(), e);
}
}
@Override
- public void updateClob( int columnIndex, Reader reader ) throws
SQLException {
- throwIfClosed();
+ public void updateClob(int columnIndex, Reader reader) throws
Review comment:
Need to keep section comment?
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
With regards,
Apache Git Services
