jena-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rve...@apache.org
Subject svn commit: r1465748 [1/2] - in /jena/Experimental/jena-jdbc: ./ jena-jdbc-core/src/main/java/org/apache/jena/jdbc/ jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/ jena-jdbc-core/src/main/java/org/apache/jena/jdbc/metadata/ jena-jdbc-cor...
Date Mon, 08 Apr 2013 19:56:05 GMT
Author: rvesse
Date: Mon Apr  8 19:56:04 2013
New Revision: 1465748

URL: http://svn.apache.org/r1465748
Log:
Set compiler to Java 6, add relevant @Override annotations for interface methods

Modified:
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/JenaDriver.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/DatasetConnection.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/JenaConnection.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/metadata/JenaMetadata.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/JenaResultSet.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/QueryExecutionResults.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/StreamedResults.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/TripleIteratorResults.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/metadata/AskResultsMetadata.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/metadata/JenaResultsMetadata.java
    jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/statements/JenaStatement.java
    jena/Experimental/jena-jdbc/pom.xml

Modified: jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/JenaDriver.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/JenaDriver.java?rev=1465748&r1=1465747&r2=1465748&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/JenaDriver.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/JenaDriver.java Mon Apr  8 19:56:04 2013
@@ -121,6 +121,7 @@ public abstract class JenaDriver impleme
         this.implPrefix = prefix;
     }
 
+    @Override
     public boolean acceptsURL(String url) throws SQLException {
         if (url.startsWith(DRIVER_PREFIX + this.implPrefix)) {
             return true;
@@ -130,6 +131,7 @@ public abstract class JenaDriver impleme
     }
 
     @SuppressWarnings("unchecked")
+    @Override
     public Connection connect(String url, Properties props) throws SQLException {
         // Make sure to return null if the URL is not supported
         if (!this.acceptsURL(url))
@@ -235,10 +237,12 @@ public abstract class JenaDriver impleme
      */
     protected abstract Connection connect(Properties props, int compatabilityLevel) throws SQLException;
 
+    @Override
     public int getMajorVersion() {
         return this.minorVer;
     }
 
+    @Override
     public int getMinorVersion() {
         return this.majorVer;
     }
@@ -253,6 +257,7 @@ public abstract class JenaDriver impleme
      * compliance requires support for SQL-92 and since we are using SPARQL we
      * don't meet that criteria
      */
+    @Override
     public final boolean jdbcCompliant() {
         // This has to be false since we are not JDBC compliant in that
         // we use SPARQL in place of SQL-92

Modified: jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/DatasetConnection.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/DatasetConnection.java?rev=1465748&r1=1465747&r2=1465748&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/DatasetConnection.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/DatasetConnection.java Mon Apr  8 19:56:04 2013
@@ -93,18 +93,15 @@ public abstract class DatasetConnection 
                 this.getTransactionIsolation());
     }
 
-    @Override
-    public boolean isClosed() throws SQLException {
+    @Override public boolean isClosed() throws SQLException {
         return this.ds == null;
     }
 
-    @Override
-    public boolean isReadOnly() throws SQLException {
+    @Override public boolean isReadOnly() throws SQLException {
         return this.readonly;
     }
 
-    @Override
-    public boolean isValid(int timeout) throws SQLException {
+    @Override public boolean isValid(int timeout) throws SQLException {
         return !this.isClosed();
     }
 

Modified: jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/JenaConnection.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/JenaConnection.java?rev=1465748&r1=1465747&r2=1465748&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/JenaConnection.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/connections/JenaConnection.java Mon Apr  8 19:56:04 2013
@@ -94,38 +94,48 @@ public abstract class JenaConnection imp
         this.setTransactionIsolation(transactionLevel);
         this.compatibilityLevel = JdbcCompatibility.normalizeLevel(compatibilityLevel);
     }
-    
+
     /**
-     * Gets the JDBC compatibility level that is in use, see {@link JdbcCompatibility} for explanations
+     * Gets the JDBC compatibility level that is in use, see
+     * {@link JdbcCompatibility} for explanations
+     * 
      * @return Compatibility level
      */
     public int getJdbcCompatibilityLevel() {
         return this.compatibilityLevel;
     }
-    
+
     /**
-     * Sets the JDBC compatibility level that is in use, see {@link JdbcCompatibility} for explanations.
+     * Sets the JDBC compatibility level that is in use, see
+     * {@link JdbcCompatibility} for explanations.
      * <p>
-     * Changing the level may not effect existing open objects, behaviour in this case will be implementation specific.
+     * Changing the level may not effect existing open objects, behaviour in
+     * this case will be implementation specific.
      * </p>
-     * @param level Compatibility level
+     * 
+     * @param level
+     *            Compatibility level
      */
     public void setJdbcCompatibilityLevel(int level) {
         this.compatibilityLevel = JdbcCompatibility.normalizeLevel(level);
     }
 
+    @Override
     public boolean isWrapperFor(Class<?> arg0) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public <T> T unwrap(Class<T> arg0) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public void clearWarnings() throws SQLException {
         this.warnings = null;
     }
 
+    @Override
     public final void close() throws SQLException {
         try {
             // Close any open statements
@@ -145,6 +155,7 @@ public abstract class JenaConnection imp
 
     protected abstract void closeInternal() throws SQLException;
 
+    @Override
     public void commit() throws SQLException {
         if (this.isClosed())
             throw new SQLException("Cannot commit on a closed connection");
@@ -167,38 +178,46 @@ public abstract class JenaConnection imp
 
     protected abstract void commitInternal() throws SQLException;
 
+    @Override
     public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Blob createBlob() throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Clob createClob() throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public NClob createNClob() throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public SQLXML createSQLXML() throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public final Statement createStatement() throws SQLException {
         if (this.isClosed())
             throw new SQLException("Cannot create a statement after the connection was closed");
         return this.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
     }
 
+    @Override
     public final Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
         if (this.isClosed())
             throw new SQLException("Cannot create a statement after the connection was closed");
         return this.createStatement(resultSetType, resultSetConcurrency, this.getHoldability());
     }
 
+    @Override
     public final Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
             throws SQLException {
         if (this.isClosed())
@@ -211,85 +230,110 @@ public abstract class JenaConnection imp
     protected abstract Statement createStatementInternal(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
             throws SQLException;
 
+    @Override
     public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public boolean getAutoCommit() throws SQLException {
         return this.autoCommit;
     }
 
+    @Override
     public String getCatalog() throws SQLException {
         return JenaMetadata.DEFAULT_CATALOG;
     }
 
+    @Override
     public Properties getClientInfo() throws SQLException {
         return this.clientInfo;
     }
 
+    @Override
     public String getClientInfo(String name) throws SQLException {
         return this.clientInfo.getProperty(name);
     }
 
+    @Override
     public int getHoldability() throws SQLException {
         return this.holdability;
     }
 
+    @Override
     public abstract DatabaseMetaData getMetaData() throws SQLException;
 
+    @Override
     public int getTransactionIsolation() throws SQLException {
         return this.isolationLevel;
     }
 
+    @Override
     public Map<String, Class<?>> getTypeMap() throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public SQLWarning getWarnings() throws SQLException {
         return this.warnings;
     }
 
+    @Override
     public abstract boolean isClosed() throws SQLException;
 
+    @Override
     public abstract boolean isReadOnly() throws SQLException;
 
+    @Override
     public abstract boolean isValid(int timeout) throws SQLException;
 
+    @Override
     public String nativeSQL(String sql) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public CallableStatement prepareCall(String sql) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
             throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public abstract PreparedStatement prepareStatement(String sql) throws SQLException;
 
+    @Override
     public abstract PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException;
 
+    @Override
     public abstract PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException;
 
+    @Override
     public abstract PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException;
 
+    @Override
     public abstract PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
             throws SQLException;
 
+    @Override
     public abstract PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
             int resultSetHoldability) throws SQLException;
 
+    @Override
     public void releaseSavepoint(Savepoint savepoint) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public void rollback() throws SQLException {
         if (this.isClosed())
             throw new SQLException("Cannot rollback on a closed connection");
@@ -311,26 +355,32 @@ public abstract class JenaConnection imp
 
     protected abstract void rollbackInternal() throws SQLException;
 
+    @Override
     public void rollback(Savepoint savepoint) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public void setAutoCommit(boolean autoCommit) throws SQLException {
         this.autoCommit = autoCommit;
     }
 
+    @Override
     public void setCatalog(String catalog) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public void setClientInfo(Properties properties) throws SQLClientInfoException {
         this.clientInfo = properties;
     }
 
+    @Override
     public void setClientInfo(String name, String value) throws SQLClientInfoException {
         this.clientInfo.put(name, value);
     }
 
+    @Override
     public void setHoldability(int holdability) throws SQLException {
         this.checkHoldability(holdability);
         this.holdability = holdability;
@@ -355,16 +405,20 @@ public abstract class JenaConnection imp
         }
     }
 
+    @Override
     public abstract void setReadOnly(boolean readOnly) throws SQLException;
 
+    @Override
     public Savepoint setSavepoint() throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Savepoint setSavepoint(String name) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public void setTransactionIsolation(int level) throws SQLException {
         this.checkTransactionIsolation(level);
         this.isolationLevel = level;
@@ -382,6 +436,7 @@ public abstract class JenaConnection imp
      */
     protected abstract void checkTransactionIsolation(int level) throws SQLException;
 
+    @Override
     public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }

Modified: jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/metadata/JenaMetadata.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/metadata/JenaMetadata.java?rev=1465748&r1=1465747&r2=1465748&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/metadata/JenaMetadata.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/metadata/JenaMetadata.java Mon Apr  8 19:56:04 2013
@@ -73,70 +73,84 @@ public abstract class JenaMetadata imple
         this.connection = connection;
     }
 
+    @Override
     public boolean isWrapperFor(Class<?> arg0) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public <T> T unwrap(Class<T> arg0) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public boolean allProceduresAreCallable() throws SQLException {
         // Callable procedures not supported in SPARQL
         return false;
     }
 
+    @Override
     public boolean allTablesAreSelectable() throws SQLException {
         // There is a single table in RDF (the quads table) and it is selectable
         return true;
     }
 
+    @Override
     public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
         // Auto-commit failure does not close all result sets
         return false;
     }
 
+    @Override
     public boolean dataDefinitionCausesTransactionCommit() throws SQLException {
         // SPARQL Update causes a commit by default for non-transactional
         // connections
         return true;
     }
 
+    @Override
     public boolean dataDefinitionIgnoredInTransactions() throws SQLException {
         // SPARQL Update is not ignored for non-transactional connections
         return false;
     }
 
+    @Override
     public boolean deletesAreDetected(int arg0) throws SQLException {
         // Since modification of result sets is not supported we can report
         // true for the ability to detect row deletes
         return true;
     }
 
+    @Override
     public boolean doesMaxRowSizeIncludeBlobs() throws SQLException {
         // There is no max row size in RDF/SPARQL
         return true;
     }
 
+    @Override
     public ResultSet getAttributes(String arg0, String arg1, String arg2, String arg3) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getBestRowIdentifier(String arg0, String arg1, String arg2, int arg3, boolean arg4) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public String getCatalogSeparator() throws SQLException {
         // Use a . since that's what SQL would use AFAIK
         return ".";
     }
 
+    @Override
     public String getCatalogTerm() throws SQLException {
         return CATALOG_TERM;
     }
 
+    @Override
     public ResultSet getCatalogs() throws SQLException {
         // TODO Requires a result set implementation that can be appropriately
         // configured
@@ -145,56 +159,72 @@ public abstract class JenaMetadata imple
         return null;
     }
 
+    @Override
     public ResultSet getClientInfoProperties() throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getColumnPrivileges(String arg0, String arg1, String arg2, String arg3) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getColumns(String arg0, String arg1, String arg2, String arg3) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public final Connection getConnection() throws SQLException {
         return this.connection;
     }
 
+    @Override
     public ResultSet getCrossReference(String arg0, String arg1, String arg2, String arg3, String arg4, String arg5)
             throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public abstract int getDatabaseMajorVersion() throws SQLException;
 
+    @Override
     public abstract int getDatabaseMinorVersion() throws SQLException;
 
+    @Override
     public abstract String getDatabaseProductName() throws SQLException;
 
+    @Override
     public abstract String getDatabaseProductVersion() throws SQLException;
 
+    @Override
     public int getDefaultTransactionIsolation() throws SQLException {
         return Connection.TRANSACTION_NONE;
     }
 
+    @Override
     public abstract int getDriverMajorVersion();
 
+    @Override
     public abstract int getDriverMinorVersion();
 
+    @Override
     public abstract String getDriverName() throws SQLException;
 
+    @Override
     public abstract String getDriverVersion() throws SQLException;
 
+    @Override
     public ResultSet getExportedKeys(String arg0, String arg1, String arg2) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public String getExtraNameCharacters() throws SQLException {
         // Since SPARQL doesn't really have a notion of identifiers like SQL
         // does
@@ -202,623 +232,745 @@ public abstract class JenaMetadata imple
         return "";
     }
 
+    @Override
     public ResultSet getFunctionColumns(String arg0, String arg1, String arg2, String arg3) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getFunctions(String arg0, String arg1, String arg2) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public String getIdentifierQuoteString() throws SQLException {
         // Not supported in SPARQL so return space per the JDBC javadoc
         return " ";
     }
 
+    @Override
     public ResultSet getImportedKeys(String arg0, String arg1, String arg2) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getIndexInfo(String arg0, String arg1, String arg2, boolean arg3, boolean arg4) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public final int getJDBCMajorVersion() throws SQLException {
         return 4;
     }
 
+    @Override
     public final int getJDBCMinorVersion() throws SQLException {
         return 0;
     }
 
+    @Override
     public int getMaxBinaryLiteralLength() throws SQLException {
         // No limit on RDF term sizes
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxCatalogNameLength() throws SQLException {
         // No limit on catalog name lengths because we don't
         // really support catalogs
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxCharLiteralLength() throws SQLException {
         // No limit on RDF term sizes
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxColumnNameLength() throws SQLException {
         // No limit on column name lengths
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxColumnsInGroupBy() throws SQLException {
         // SPARQL allows arbitrarily many columns in a GROUP BY
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxColumnsInIndex() throws SQLException {
         // RDF stores typically index on up to 3 columns since there are only 4
         // columns
         return 3;
     }
 
+    @Override
     public int getMaxColumnsInOrderBy() throws SQLException {
         // SPARQL allows arbitrarily many columns in ORDER BY
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxColumnsInSelect() throws SQLException {
         // SPARQL allows arbitrarily many columns in SELECT clause
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxColumnsInTable() throws SQLException {
         // RDF stores have up to 4 columns
         return 4;
     }
 
+    @Override
     public int getMaxConnections() throws SQLException {
         // Max connections will typically be unlimited
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxCursorNameLength() throws SQLException {
         // Named cursors aren't supported so there is no limit
         return UNKNOWN_LIMIT;
     }
 
+    @Override
     public int getMaxIndexLength() throws SQLException {
         // RDF stores typically have no limit on index size, they are as big as
         // they need to be
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxProcedureNameLength() throws SQLException {
         // Procedures aren't supported so unknown
         return UNKNOWN_LIMIT;
     }
 
+    @Override
     public int getMaxRowSize() throws SQLException {
         // No limit on triple size
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxSchemaNameLength() throws SQLException {
         // We don't really support schemas so there is no limit
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxStatementLength() throws SQLException {
         // SPARQL Queries/Updates may be arbitrarily large
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxStatements() throws SQLException {
         // We don't impose any limit on this
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxTableNameLength() throws SQLException {
         // We don't support tables so there is no limit
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxTablesInSelect() throws SQLException {
         // No limit
         return NO_LIMIT;
     }
 
+    @Override
     public int getMaxUserNameLength() throws SQLException {
         // Authentication is an implementation specific detail so unknown
         return UNKNOWN_LIMIT;
     }
 
+    @Override
     public String getNumericFunctions() throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getPrimaryKeys(String arg0, String arg1, String arg2) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getProcedureColumns(String arg0, String arg1, String arg2, String arg3) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public String getProcedureTerm() throws SQLException {
         // Not supported
         return null;
     }
 
+    @Override
     public ResultSet getProcedures(String arg0, String arg1, String arg2) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public int getResultSetHoldability() throws SQLException {
         return JenaConnection.DEFAULT_HOLDABILITY;
     }
 
+    @Override
     public RowIdLifetime getRowIdLifetime() throws SQLException {
         // Not supported
         return RowIdLifetime.ROWID_UNSUPPORTED;
     }
 
+    @Override
     public String getSQLKeywords() throws SQLException {
         // TODO Use http://developer.mimer.com/validator/sql-reserved-words.tml
         // as a reference to implement this
         return null;
     }
 
+    @Override
     public int getSQLStateType() throws SQLException {
         return sqlStateXOpen;
     }
 
+    @Override
     public String getSchemaTerm() throws SQLException {
         return SCHEMA_TERM;
     }
 
+    @Override
     public ResultSet getSchemas() throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getSchemas(String arg0, String arg1) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public String getSearchStringEscape() throws SQLException {
         // Does not apply to SPARQL
         return "";
     }
 
+    @Override
     public String getStringFunctions() throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getSuperTables(String arg0, String arg1, String arg2) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getSuperTypes(String arg0, String arg1, String arg2) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public String getSystemFunctions() throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getTablePrivileges(String arg0, String arg1, String arg2) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getTableTypes() throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getTables(String arg0, String arg1, String arg2, String[] arg3) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public String getTimeDateFunctions() throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getTypeInfo() throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public ResultSet getUDTs(String arg0, String arg1, String arg2, int[] arg3) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public abstract String getURL() throws SQLException;
 
+    @Override
     public String getUserName() throws SQLException {
         // No authentication used by default
         return null;
     }
 
+    @Override
     public ResultSet getVersionColumns(String arg0, String arg1, String arg2) throws SQLException {
         // TODO Auto-generated method stub
         return null;
     }
 
+    @Override
     public boolean insertsAreDetected(int arg0) throws SQLException {
         // We can't detect inserts that happen while streaming results
         return false;
     }
 
+    @Override
     public boolean isCatalogAtStart() throws SQLException {
         // We don't really support catalogs so we'll say yes
         return true;
     }
 
+    @Override
     public boolean isReadOnly() throws SQLException {
         return this.connection.isReadOnly();
     }
 
+    @Override
     public boolean locatorsUpdateCopy() throws SQLException {
         // TODO Auto-generated method stub
         return false;
     }
 
+    @Override
     public boolean nullPlusNonNullIsNull() throws SQLException {
         // Concatenating nulls (i.e. unbound/type error) in SPARQL results
         // leads to nulls
         return true;
     }
 
+    @Override
     public boolean nullsAreSortedAtEnd() throws SQLException {
         // SPARQL sort order puts nulls (i.e. unbound) first
         return false;
     }
 
+    @Override
     public boolean nullsAreSortedAtStart() throws SQLException {
         // SPARQL sort order puts nulls (i.e. unbound) first
         return true;
     }
 
+    @Override
     public boolean nullsAreSortedHigh() throws SQLException {
         // SPARQL sort order puts nulls (i.e. unbound) first
         return false;
     }
 
+    @Override
     public boolean nullsAreSortedLow() throws SQLException {
         // SPARQL sort order puts nulls (i.e. unbound) first
         return true;
     }
 
+    @Override
     public boolean othersDeletesAreVisible(int arg0) throws SQLException {
         // Since results are streamed it may be possible to see deletes from
         // others depending on the underlying implementation
         return true;
     }
 
+    @Override
     public boolean othersInsertsAreVisible(int arg0) throws SQLException {
         // Since results are streamed it may be possible to see inserts from
         // others depending on the underlying implementation
         return true;
     }
 
+    @Override
     public boolean othersUpdatesAreVisible(int arg0) throws SQLException {
         // Since results are streamed it may be possible to see updates from
         // others depending on the underlying implementation
         return true;
     }
 
+    @Override
     public boolean ownDeletesAreVisible(int arg0) throws SQLException {
         // Since results are streamed it may be possible to see deletes from
         // ourselves depending on the underlying implementation
         return true;
     }
 
+    @Override
     public boolean ownInsertsAreVisible(int arg0) throws SQLException {
         // Since results are streamed it may be possible to see inserts from
         // ourselves depending on the underlying implementation
         return true;
     }
 
+    @Override
     public boolean ownUpdatesAreVisible(int arg0) throws SQLException {
         // Since results are streamed it may be possible to see deletes from
         // others depending on the underlying implementation
         return true;
     }
 
+    @Override
     public boolean storesLowerCaseIdentifiers() throws SQLException {
         // We don't support identifiers in the way that JDBC means so we say
         // false
         return false;
     }
 
+    @Override
     public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
         // We don't support identifiers in the way that JDBC means so we say
         // false
         return false;
     }
 
+    @Override
     public boolean storesMixedCaseIdentifiers() throws SQLException {
         // We don't support identifiers in the way that JDBC means so we say
         // false
         return false;
     }
 
+    @Override
     public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
         // We don't support identifiers in the way that JDBC means so we say
         // false
         return false;
     }
 
+    @Override
     public boolean storesUpperCaseIdentifiers() throws SQLException {
         // We don't support identifiers in the way that JDBC means so we say
         // false
         return false;
     }
 
+    @Override
     public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
         // We don't support identifiers in the way that JDBC means so we say
         // false
         return false;
     }
 
+    @Override
     public boolean supportsANSI92EntryLevelSQL() throws SQLException {
         // We don't support SQL
         return false;
     }
 
+    @Override
     public boolean supportsANSI92FullSQL() throws SQLException {
         // We don't support SQL
         return false;
     }
 
+    @Override
     public boolean supportsANSI92IntermediateSQL() throws SQLException {
         // We don't support SQL
         return false;
     }
 
+    @Override
     public boolean supportsAlterTableWithAddColumn() throws SQLException {
         // Schema alteration is not supported
         return false;
     }
 
+    @Override
     public boolean supportsAlterTableWithDropColumn() throws SQLException {
         // Schema alteration is not supported
         return false;
     }
 
+    @Override
     public boolean supportsBatchUpdates() throws SQLException {
         // Batch updates are implemented
         return true;
     }
 
+    @Override
     public boolean supportsCatalogsInDataManipulation() throws SQLException {
         // We don't really support catalogs so using them in SPARQL Update is
         // not permitted
         return false;
     }
 
+    @Override
     public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
         // Custom indexes are not supported
         return false;
     }
 
+    @Override
     public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
         // SPARQL has no privilege definition statements
         return false;
     }
 
+    @Override
     public boolean supportsCatalogsInProcedureCalls() throws SQLException {
         // SPARQL has no procedure calls
         return false;
     }
 
+    @Override
     public boolean supportsCatalogsInTableDefinitions() throws SQLException {
         // SPARQL has no table definition statements
         return false;
     }
 
+    @Override
     public boolean supportsColumnAliasing() throws SQLException {
         // SPARQL requires aliasing for computed columns
         return true;
     }
 
+    @Override
     public boolean supportsConvert() throws SQLException {
         // JDBC convert is not supported
         return false;
     }
 
+    @Override
     public boolean supportsConvert(int arg0, int arg1) throws SQLException {
         // JDBC convert is not supported
         return false;
     }
 
+    @Override
     public boolean supportsCoreSQLGrammar() throws SQLException {
         // We don't support SQL
         return false;
     }
 
+    @Override
     public boolean supportsCorrelatedSubqueries() throws SQLException {
         // SPARQL supports sub-queries
         return true;
     }
 
+    @Override
     public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
         // SPARQL update may be used within a transaction
         return true;
     }
 
+    @Override
     public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
         // Transactions may consist only of SPARQL updates
         return true;
     }
 
+    @Override
     public boolean supportsDifferentTableCorrelationNames() throws SQLException {
         // We don't support tables as such so no
         return false;
     }
 
+    @Override
     public boolean supportsExpressionsInOrderBy() throws SQLException {
         // SPARQL allows expressions in ORDER BY
         return true;
     }
 
+    @Override
     public boolean supportsExtendedSQLGrammar() throws SQLException {
         // We don't support SQL
         return false;
     }
 
+    @Override
     public boolean supportsFullOuterJoins() throws SQLException {
         // SPARQL supports all sorts of joins
         return true;
     }
 
+    @Override
     public boolean supportsGetGeneratedKeys() throws SQLException {
         // SPARQL has no notion of auto-generated keys (you can argue that
         // UUID() counts) but we certainly can't return them
         return true;
     }
 
+    @Override
     public boolean supportsGroupBy() throws SQLException {
         // SPARQL supports GROUP BY
         return true;
     }
 
+    @Override
     public boolean supportsGroupByBeyondSelect() throws SQLException {
         // You can GROUP BY a column that you don't select in SPARQL
         return true;
     }
 
+    @Override
     public boolean supportsGroupByUnrelated() throws SQLException {
         // You can GROUP BY a column that you don't select in SPARQL
         return true;
     }
 
+    @Override
     public boolean supportsIntegrityEnhancementFacility() throws SQLException {
         // Integrity Enhancement SQL is not supported
         return false;
     }
 
+    @Override
     public boolean supportsLikeEscapeClause() throws SQLException {
         // No LIKE in SPARQL
         return false;
     }
 
+    @Override
     public boolean supportsLimitedOuterJoins() throws SQLException {
         // SPARQL supports all kinds of joins
         return true;
     }
 
+    @Override
     public boolean supportsMinimumSQLGrammar() throws SQLException {
         // We don't support SQL
         return false;
     }
 
+    @Override
     public boolean supportsMixedCaseIdentifiers() throws SQLException {
         // We have no direct equivalent to SQL identifiers
         return false;
     }
 
+    @Override
     public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
         // We have no direct equivalent to SQL identifiers
         return false;
     }
 
+    @Override
     public boolean supportsMultipleOpenResults() throws SQLException {
         // We support multiple open results
         return true;
     }
 
+    @Override
     public boolean supportsMultipleResultSets() throws SQLException {
         // We don't support multiple result sets from a single execute() call,
         // we do support this from executeBatch()
         return false;
     }
 
+    @Override
     public boolean supportsMultipleTransactions() throws SQLException {
         // In principle yes this is possible though exact behaviour may vary by
         // underlying implementation
         return true;
     }
 
+    @Override
     public boolean supportsNamedParameters() throws SQLException {
         // We don't support callable statements
         return false;
     }
 
+    @Override
     public boolean supportsNonNullableColumns() throws SQLException {
         // All columns in a RDF store are non-nullable
         return true;
     }
 
+    @Override
     public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
         // Cursors may be closed depending on the type of commit
         return false;
     }
 
+    @Override
     public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
         // Cursors may be closed depending on the type of commit
         return false;
     }
 
+    @Override
     public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
         // Statements remain open across commits
         return true;
     }
 
+    @Override
     public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
         // Statements remain open across rollbacks
         return true;
     }
 
+    @Override
     public boolean supportsOrderByUnrelated() throws SQLException {
         // SPARQL allows ORDER BY on a column that you don't SELECT
         return true;
     }
 
+    @Override
     public boolean supportsOuterJoins() throws SQLException {
         // SPARQL supports all kinds of joins
         return true;
     }
 
+    @Override
     public boolean supportsPositionedDelete() throws SQLException {
         // We don't support deleting from result set
         return false;
     }
 
+    @Override
     public boolean supportsPositionedUpdate() throws SQLException {
         // We don't support updating from result set
         return false;
     }
 
+    @Override
     public boolean supportsResultSetConcurrency(int arg0, int arg1) throws SQLException {
         // TODO Auto-generated method stub
         return false;
     }
 
+    @Override
     public boolean supportsResultSetHoldability(int arg0) throws SQLException {
         // Both kinds of holdability are supported
         return true;
     }
 
+    @Override
     public boolean supportsResultSetType(int arg0) throws SQLException {
         // Currently only FORWARD_ONLY is supported
         switch (arg0) {
@@ -829,83 +981,99 @@ public abstract class JenaMetadata imple
         }
     }
 
+    @Override
     public boolean supportsSavepoints() throws SQLException {
         // No notion of savepoints
         return false;
     }
 
+    @Override
     public boolean supportsSchemasInDataManipulation() throws SQLException {
         // We don't really support schemas
         return false;
     }
 
+    @Override
     public boolean supportsSchemasInIndexDefinitions() throws SQLException {
         // RDF stores don't allow custom indices
         return false;
     }
 
+    @Override
     public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
         // SPARQL has no privilege definition statements
         return false;
     }
 
+    @Override
     public boolean supportsSchemasInProcedureCalls() throws SQLException {
         // SPARQL has no procedure calls
         return false;
     }
 
+    @Override
     public boolean supportsSchemasInTableDefinitions() throws SQLException {
         // We don't really support schemas
         return false;
     }
 
+    @Override
     public boolean supportsSelectForUpdate() throws SQLException {
         // No SPARQL equivalent
         return false;
     }
 
+    @Override
     public boolean supportsStatementPooling() throws SQLException {
         // We don't do pooling
         return false;
     }
 
+    @Override
     public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
         // Stored procedures are not supported in SPARQL
         return false;
     }
 
+    @Override
     public boolean supportsStoredProcedures() throws SQLException {
         // Stored procedures are not supported in SPARQL
         return false;
     }
 
+    @Override
     public boolean supportsSubqueriesInComparisons() throws SQLException {
         // Can't use subqueries in this way in SPARQL
         return false;
     }
 
+    @Override
     public boolean supportsSubqueriesInExists() throws SQLException {
         // SPARQL does allow sub-queries in EXISTS though strictly speaking our
         // EXISTS has no relation to the SQL equivalent
         return true;
     }
 
+    @Override
     public boolean supportsSubqueriesInIns() throws SQLException {
         // Can't use subqueries in this way in SPARQL
         return false;
     }
 
+    @Override
     public boolean supportsSubqueriesInQuantifieds() throws SQLException {
         // I have no idea what this mean so assume we can't use sub-queries this
         // way in SPARQL
         return false;
     }
 
+    @Override
     public boolean supportsTableCorrelationNames() throws SQLException {
         // We don't really support tables
         return false;
     }
 
+    @Override
     public boolean supportsTransactionIsolationLevel(int arg0) throws SQLException {
         // Currently only None or Serializable is supported
         switch (arg0) {
@@ -917,28 +1085,34 @@ public abstract class JenaMetadata imple
         }
     }
 
+    @Override
     public boolean supportsTransactions() throws SQLException {
         // Currently transactions are not supported
         return false;
     }
 
+    @Override
     public boolean supportsUnion() throws SQLException {
         // SPARQL supports UNION
         return true;
     }
 
+    @Override
     public boolean supportsUnionAll() throws SQLException {
         // No SPARQL equivalent of UNION ALL
         return false;
     }
 
+    @Override
     public boolean updatesAreDetected(int arg0) throws SQLException {
         // Updates are never detectable
         return false;
     }
 
+    @Override
     public abstract boolean usesLocalFilePerTable() throws SQLException;
 
+    @Override
     public abstract boolean usesLocalFiles() throws SQLException;
 
 }

Modified: jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/JenaResultSet.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/JenaResultSet.java?rev=1465748&r1=1465747&r2=1465748&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/JenaResultSet.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/JenaResultSet.java Mon Apr  8 19:56:04 2013
@@ -75,7 +75,8 @@ public abstract class JenaResultSet impl
         if (statement == null)
             throw new SQLException("Statement for a Result Set cannot be null");
         this.statement = statement;
-        this.compatibilityLevel = JdbcCompatibility.normalizeLevel(this.statement.getJenaConnection().getJdbcCompatibilityLevel());
+        this.compatibilityLevel = JdbcCompatibility
+                .normalizeLevel(this.statement.getJenaConnection().getJdbcCompatibilityLevel());
     }
 
     /**
@@ -99,34 +100,42 @@ public abstract class JenaResultSet impl
         return this.compatibilityLevel;
     }
 
+    @Override
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public void cancelRowUpdates() throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public final void clearWarnings() throws SQLException {
         this.warnings = null;
     }
 
+    @Override
     public void deleteRow() throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public final int getHoldability() throws SQLException {
         return this.holdability;
     }
 
+    @Override
     public final int getConcurrency() throws SQLException {
         return ResultSet.CONCUR_READ_ONLY;
     }
 
+    @Override
     public abstract ResultSetMetaData getMetaData() throws SQLException;
 
     // Get Methods for things we do support
@@ -171,10 +180,12 @@ public abstract class JenaResultSet impl
      */
     protected abstract Node getNode(String columnLabel) throws SQLException;
 
+    @Override
     public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
         return this.getBigDecimal(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -187,10 +198,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public boolean getBoolean(int columnIndex) throws SQLException {
         return this.getBoolean(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public boolean getBoolean(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -203,10 +216,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public byte getByte(int columnIndex) throws SQLException {
         return this.getByte(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public byte getByte(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -219,10 +234,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public Date getDate(int columnIndex) throws SQLException {
         return this.getDate(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public Date getDate(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -235,10 +252,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public double getDouble(int columnIndex) throws SQLException {
         return this.getDouble(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public double getDouble(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -251,10 +270,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public float getFloat(int columnIndex) throws SQLException {
         return this.getFloat(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public float getFloat(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -267,10 +288,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public int getInt(int columnIndex) throws SQLException {
         return this.getInt(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public int getInt(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -283,10 +306,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public long getLong(int columnIndex) throws SQLException {
         return this.getLong(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public long getLong(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -299,10 +324,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public String getNString(int columnIndex) throws SQLException {
         return this.getNString(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public String getNString(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -314,10 +341,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public Object getObject(int columnIndex) throws SQLException {
         return this.getObject(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public Object getObject(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -329,10 +358,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public short getShort(int columnIndex) throws SQLException {
         return this.getShort(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public short getShort(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -345,10 +376,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public String getString(int columnIndex) throws SQLException {
         return this.getString(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public String getString(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -360,10 +393,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public Time getTime(int columnIndex) throws SQLException {
         return this.getTime(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public Time getTime(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -376,10 +411,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public Timestamp getTimestamp(int columnIndex) throws SQLException {
         return this.getTimestamp(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public Timestamp getTimestamp(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -392,10 +429,12 @@ public abstract class JenaResultSet impl
         }
     }
 
+    @Override
     public URL getURL(int columnIndex) throws SQLException {
         return this.getURL(this.findColumnLabel(columnIndex));
     }
 
+    @Override
     public URL getURL(String columnLabel) throws SQLException {
         Node n = this.getNode(columnLabel);
         if (n == null) {
@@ -409,162 +448,201 @@ public abstract class JenaResultSet impl
 
     // Get Methods for things we don't support
 
+    @Override
     public Array getArray(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Array getArray(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public InputStream getAsciiStream(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public InputStream getAsciiStream(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
     @Deprecated
+    @Override
     public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
     @Deprecated
+    @Override
     public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public InputStream getBinaryStream(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public InputStream getBinaryStream(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Blob getBlob(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Blob getBlob(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public byte[] getBytes(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public byte[] getBytes(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Reader getCharacterStream(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Reader getCharacterStream(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Clob getClob(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Clob getClob(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public String getCursorName() throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Date getDate(int columnIndex, Calendar cal) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Date getDate(String columnLabel, Calendar cal) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Reader getNCharacterStream(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Reader getNCharacterStream(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public NClob getNClob(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public NClob getNClob(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Ref getRef(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Ref getRef(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public RowId getRowId(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public RowId getRowId(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public SQLXML getSQLXML(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public SQLXML getSQLXML(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Statement getStatement() throws SQLException {
         return this.statement;
     }
 
+    @Override
     public Time getTime(int columnIndex, Calendar cal) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Time getTime(String columnLabel, Calendar cal) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
     @Deprecated
+    @Override
     public InputStream getUnicodeStream(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
     @Deprecated
+    @Override
     public InputStream getUnicodeStream(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public final SQLWarning getWarnings() throws SQLException {
         return this.warnings;
     }
@@ -607,370 +685,462 @@ public abstract class JenaResultSet impl
         this.setWarning(new SQLWarning(warning, cause));
     }
 
+    @Override
     public void insertRow() throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void moveToCurrentRow() throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
 
+    @Override
     public void moveToInsertRow() throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public boolean previous() throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are forward-only");
     }
 
+    @Override
     public void refreshRow() throws SQLException {
         // No-op
     }
 
+    @Override
     public boolean rowDeleted() throws SQLException {
         return false;
     }
 
+    @Override
     public boolean rowInserted() throws SQLException {
         return false;
     }
 
+    @Override
     public boolean rowUpdated() throws SQLException {
         return false;
     }
 
+    @Override
     public void updateArray(int columnIndex, Array x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateArray(String columnLabel, Array x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBlob(int columnIndex, Blob x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBlob(String columnLabel, Blob x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBoolean(int columnIndex, boolean x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBoolean(String columnLabel, boolean x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateByte(int columnIndex, byte x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateByte(String columnLabel, byte x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBytes(int columnIndex, byte[] x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateBytes(String columnLabel, byte[] x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateClob(int columnIndex, Clob x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateClob(int columnIndex, Reader reader) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateClob(String columnLabel, Clob x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateClob(String columnLabel, Reader reader) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateDate(int columnIndex, Date x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateDate(String columnLabel, Date x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateDouble(int columnIndex, double x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateDouble(String columnLabel, double x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateFloat(int columnIndex, float x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateFloat(String columnLabel, float x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateInt(int columnIndex, int x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateInt(String columnLabel, int x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateLong(int columnIndex, long x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateLong(String columnLabel, long x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNClob(int columnIndex, Reader reader) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNClob(String columnLabel, Reader reader) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNString(int columnIndex, String nString) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNString(String columnLabel, String nString) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNull(int columnIndex) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateNull(String columnLabel) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateObject(int columnIndex, Object x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateObject(String columnLabel, Object x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateRef(int columnIndex, Ref x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateRef(String columnLabel, Ref x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateRow() throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateRowId(int columnIndex, RowId x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateRowId(String columnLabel, RowId x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateShort(int columnIndex, short x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateShort(String columnLabel, short x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateString(int columnIndex, String x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateString(String columnLabel, String x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateTime(int columnIndex, Time x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateTime(String columnLabel, Time x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
         throw new SQLFeatureNotSupportedException("Jena JDBC Result Sets are read-only");
     }
 
+    @Override
     public boolean wasNull() throws SQLException {
         return this.wasNull;
     }

Modified: jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/QueryExecutionResults.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/QueryExecutionResults.java?rev=1465748&r1=1465747&r2=1465748&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/QueryExecutionResults.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-core/src/main/java/org/apache/jena/jdbc/results/QueryExecutionResults.java Mon Apr  8 19:56:04 2013
@@ -49,6 +49,7 @@ public abstract class QueryExecutionResu
     /**
      * Closes the results which also closes the underlying {@link QueryExecution}
      */
+    @Override
     public final void close() throws SQLException {
         if (this.qe != null) {
             try {
@@ -74,6 +75,7 @@ public abstract class QueryExecutionResu
      */
     protected abstract void closeInternal() throws SQLException;
 
+    @Override
     public final boolean isClosed() throws SQLException {
         return this.qe == null;
     }



Mime
View raw message