You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by rv...@apache.org on 2013/04/08 21:56:05 UTC
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...
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;
}