monetdb-java: src/main/java/nl/cwi/monetdb/jdbc/MonetConnection.java comparison

comparison src/main/java/nl/cwi/monetdb/jdbc/MonetConnection.java @ 262:2d62ca1f758b

Moved utility method newSQLFeatureNotSupportedException(String name) from MonetPreparedStatement.java and MonetResultSet.java to class MonetWrapper such that it can be called directly from all classes which extend MonetWrapper. Call MonetWrapper.newSQLFeatureNotSupportedException() from more classes and places. Update java documentation: - add "@throws SQLFeatureNotSupportedException" to methods which can throw it - remove "@throws SQLFeatureNotSupportedException" from methods which do not throw it

author	Martin van Dinther <martin.van.dinther@monetdbsolutions.com>
date	Thu, 03 Jan 2019 18:33:25 +0100 (2019-01-03)
parents	d4baf8a4b43a
children	eefa7f625673

comparison

equal deleted inserted replaced

-:d4baf8a4b43a
+:2d62ca1f758b
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLClientInfoException;
 import java.sql.SQLException;
-import java.sql.SQLFeatureNotSupportedException;
 import java.sql.SQLNonTransientConnectionException;
 import java.sql.SQLWarning;
 import java.sql.Savepoint;
 import java.sql.Statement;
 import java.util.ArrayList;
 	 *
 	 * @return the current state of this Connection object's auto-commit mode
 	 * @see #setAutoCommit(boolean)
 	 */
 	@Override
-	public boolean getAutoCommit() throws SQLException {
+	public boolean getAutoCommit() {
 		return autoCommit;
 	}
 	/**
 	 * Retrieves this Connection object's current catalog name.
 	 *
 	 * @return the current catalog name or null if there is none
-	 * @throws SQLException if a database access error occurs or the
+	 */
-	 *         current language is not SQL
+	@Override
-	 */
+	public String getCatalog() {
-	@Override
-	public String getCatalog() throws SQLException {
 		// MonetDB does NOT support catalogs
 		return null;
 	}
 	/**
 	/**
 	 * Converts the given SQL statement into the system's native SQL grammar.
 	 * A driver may convert the JDBC SQL grammar into its system's native SQL grammar prior to sending it.
 	 * This method returns the native form of the statement that the driver would have sent.
 	 *
-	 * Parameters:
+	 * @param sql - an SQL statement that may contain one or more '?' parameter placeholders.
-	 *   sql - an SQL statement that may contain one or more '?' parameter placeholders.
+	 * @return the native form of this statement
-	 * Returns: the native form of this statement
-	 * Throws: SQLException - if a database access error occurs or this method is called on a closed connection
 	 */
 	@Override
 	public String nativeSQL(String sql) {
 		/* there is currently no way to get the native MonetDB rewritten SQL string back, so just return the original string */
 		/* in future we may replace/remove the escape sequences { <escape-type> ...} before sending it to the server */
 	 *
 	 * Result sets created using the returned CallableStatement object will by default be type TYPE_FORWARD_ONLY
 	 * and have a concurrency level of CONCUR_READ_ONLY.
 	 * The holdability of the created result sets can be determined by calling getHoldability().
 	 *
-	 * Parameters:
+	 * @param sql - an SQL statement that may contain one or more '?' parameter placeholders.
-	 *   sql - an SQL statement that may contain one or more '?' parameter placeholders.
 	 *	Typically this statement is specified using JDBC call escape syntax.
-	 * Returns: a new default CallableStatement object containing the pre-compiled SQL statement
+	 * @return a new default CallableStatement object containing the pre-compiled SQL statement
-	 * Throws: SQLException - if a database access error occurs or this method is called on a closed connection
+	 * @throws SQLException - if a database access error occurs or this method is called on a closed connection
+	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this method.
 	 */
 	@Override
 	public CallableStatement prepareCall(String sql) throws SQLException {
 		return prepareCall(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
 	}
 	/**
 	 * Creates a CallableStatement object that will generate ResultSet objects with the given type and concurrency.
 	 * This method is the same as the prepareCall method above, but it allows the default result set type and concurrency to be overridden.
 	 * The holdability of the created result sets can be determined by calling getHoldability().
 	 *
-	 * Parameters:
+	 * @param sql - a String object that is the SQL statement to be sent to the database; may contain on or more '?' parameters
-	 *   sql - a String object that is the SQL statement to be sent to the database; may contain on or more '?' parameters
 	 *	Typically this statement is specified using JDBC call escape syntax.
-	 *   resultSetType - a result set type; one of ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, or ResultSet.TYPE_SCROLL_SENSITIVE
+	 * @param resultSetType - a result set type; one of ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, or ResultSet.TYPE_SCROLL_SENSITIVE
-	 *   resultSetConcurrency - a concurrency type; one of ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
+	 * @param resultSetConcurrency - a concurrency type; one of ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
-	 * Returns: a new CallableStatement object containing the pre-compiled SQL statement that
+	 * @return a new CallableStatement object containing the pre-compiled SQL statement that
 	 *	will produce ResultSet objects with the given type and concurrency
-	 * Throws:
+	 * @throws SQLException - if a database access error occurs, this method is called on a closed connection or
-	 *   SQLException - if a database access error occurs, this method is called on a closed connection or
+	 *	the given parameters are not ResultSet constants indicating type and concurrency
-	 *		the given parameters are not ResultSet constants indicating type and concurrency
+	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this method or
-	 *   SQLFeatureNotSupportedException - if the JDBC driver does not support this method or
+	 *	this method is not supported for the specified result set type and result set concurrency.
-	 *		this method is not supported for the specified result set type and result set concurrency.
 	 */
 	@Override
 	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
 		return prepareCall(sql, resultSetType, resultSetConcurrency, ResultSet.HOLD_CURSORS_OVER_COMMIT);
 	}
 	/**
 	 * Creates a CallableStatement object that will generate ResultSet objects with the given type and concurrency.
 	 * This method is the same as the prepareCall method above, but it allows the default result set type, result set concurrency type and holdability to be overridden.
 	 *
-	 * Parameters:
+	 * @param sql - a String object that is the SQL statement to be sent to the database; may contain on or more '?' parameters
-	 *   sql - a String object that is the SQL statement to be sent to the database; may contain on or more '?' parameters
 	 *	Typically this statement is specified using JDBC call escape syntax.
-	 *   resultSetType - a result set type; one of ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, or ResultSet.TYPE_SCROLL_SENSITIVE
+	 * @param resultSetType - a result set type; one of ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE, or ResultSet.TYPE_SCROLL_SENSITIVE
-	 *   resultSetConcurrency - a concurrency type; one of ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
+	 * @param resultSetConcurrency - a concurrency type; one of ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
-	 *   resultSetHoldability - one of the following ResultSet constants: ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
+	 * @param resultSetHoldability - one of the following ResultSet constants: ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
-	 * Returns: a new CallableStatement object, containing the pre-compiled SQL statement, that will generate ResultSet objects with the given type, concurrency, and holdability
+	 * @return a new CallableStatement object, containing the pre-compiled SQL statement, that will generate ResultSet objects with the given type, concurrency, and holdability
-	 * Throws:
+	 * @throws SQLException - if a database access error occurs, this method is called on a closed connection or
-	 *   SQLException - if a database access error occurs, this method is called on a closed connection or
+	 *	the given parameters are not ResultSet constants indicating type, concurrency, and holdability
-	 *		the given parameters are not ResultSet constants indicating type, concurrency, and holdability
+	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this method or
-	 *   SQLFeatureNotSupportedException - if the JDBC driver does not support this method or
+	 *	this method is not supported for the specified result set type, result set holdability and result set concurrency.
-	 *		this method is not supported for the specified result set type, result set holdability and result set concurrency.
 	 */
 	@Override
 	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
 		throws SQLException
 	{
-		throw new SQLFeatureNotSupportedException("prepareCall() not yet supported", "0A000");
+		throw newSQLFeatureNotSupportedException("prepareCall");
 		/* a request to implement prepareCall() has already been logged, see https://www.monetdb.org/bugzilla/show_bug.cgi?id=6402 */
 	}
 	/**
 	 * Creates a PreparedStatement object for sending parameterized SQL
 			statements.put(ret, null);
 			return ret;
 		} catch (IllegalArgumentException e) {
 			throw new SQLException(e.toString(), "M0M03");
 		}
-		// we don't have to catch SQLException because that is declared to
+		// we don't have to catch SQLException because that is declared to be thrown
-		// be thrown
 	}
 	/**
 	 * Creates a default PreparedStatement object that has the
 	 * capability to retrieve auto-generated keys.  The given constant
 	 *         whether auto-generated keys should be returned
 	 */
 	@Override
 	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
 		if (autoGeneratedKeys != Statement.RETURN_GENERATED_KEYS &&
-			autoGeneratedKeys != Statement.NO_GENERATED_KEYS)
+		    autoGeneratedKeys != Statement.NO_GENERATED_KEYS)
 			throw new SQLException("Invalid argument, expected RETURN_GENERATED_KEYS or NO_GENERATED_KEYS", "M1M05");
-		/* MonetDB has no way to disable this, so just do the normal
+		/* MonetDB has no way to disable this, so just do the normal thing ;) */
-		 * thing ;) */
 		return prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
 	}
 	/**
 	 * Creates a default PreparedStatement object capable of returning the auto-generated keys designated by the given array.
 	 * object is executed. This has no direct effect on users; however, it does affect which methods throw certain SQLExceptions.
 	 *
 	 * Result sets created using the returned PreparedStatement object will by default be type TYPE_FORWARD_ONLY and have
 	 * a concurrency level of CONCUR_READ_ONLY. The holdability of the created result sets can be determined by calling getHoldability().
 	 *
-	 * Parameters:
+	 * @param sql - an SQL statement that may contain one or more '?' IN parameter placeholders
-	 *     sql - an SQL statement that may contain one or more '?' IN parameter placeholders
+	 * @param columnIndexes - an array of column indexes indicating the columns that should be returned from the inserted row or rows
-	 *     columnIndexes - an array of column indexes indicating the columns that should be returned from the inserted row or rows
+	 * @return a new PreparedStatement object, containing the pre-compiled statement, that is capable of
-	 * Returns:
+	 * 	returning the auto-generated keys designated by the given array of column indexes
-	 *     a new PreparedStatement object, containing the pre-compiled statement, that is capable of
+	 * @throws SQLException - if a database access error occurs or this method is called on a closed connection
-	 *     returning the auto-generated keys designated by the given array of column indexes
+	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this method
-	 * Throws:
-	 *     SQLException - if a database access error occurs or this method is called on a closed connection
-	 *     SQLFeatureNotSupportedException - if the JDBC driver does not support this method
 	 */
 	@Override
 	public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
-		throw new SQLFeatureNotSupportedException("prepareStatement(String sql, int[] columnIndexes) not supported", "0A000");
+		throw newSQLFeatureNotSupportedException("prepareStatement(String sql, int[] columnIndexes)");
 	}
 	/**
 	 * Creates a default PreparedStatement object capable of returning the auto-generated keys designated by the given array.
 	 * This array contains the names of the columns in the target table that contain the auto-generated keys that should be returned.
 	 * object is executed. This has no direct effect on users; however, it does affect which methods throw certain SQLExceptions.
 	 *
 	 * Result sets created using the returned PreparedStatement object will by default be type TYPE_FORWARD_ONLY and have
 	 * a concurrency level of CONCUR_READ_ONLY. The holdability of the created result sets can be determined by calling getHoldability().
 	 *
-	 * Parameters:
+	 * @param sql - an SQL statement that may contain one or more '?' IN parameter placeholders
-	 *     sql - an SQL statement that may contain one or more '?' IN parameter placeholders
+	 * @param columnNames - an array of column names indicating the columns that should be returned from the inserted row or rows
-	 *     columnNames - an array of column names indicating the columns that should be returned from the inserted row or rows
+	 * @return a new PreparedStatement object, containing the pre-compiled statement, that is capable of
-	 * Returns:
+	 * 	returning the auto-generated keys designated by the given array of column names
-	 *     a new PreparedStatement object, containing the pre-compiled statement, that is capable of
+	 * @throws SQLException - if a database access error occurs or this method is called on a closed connection
-	 *     returning the auto-generated keys designated by the given array of column names
+	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this method
-	 * Throws:
-	 *     SQLException - if a database access error occurs or this method is called on a closed connection
-	 *     SQLFeatureNotSupportedException - if the JDBC driver does not support this method
 	 */
 	@Override
 	public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
-		throw new SQLFeatureNotSupportedException("prepareStatement(String sql, String[] columnNames) not supported", "0A000");
+		throw newSQLFeatureNotSupportedException("prepareStatement(String sql, String[] columnNames)");
 	}
 	/**
 	 * Removes the given Savepoint object from the current transaction.
 	 * Any reference to the savepoint after it have been removed will
 	 * Sets the given catalog name in order to select a subspace of this
 	 * Connection object's database in which to work.  If the driver
 	 * does not support catalogs, it will silently ignore this request.
 	 */
 	@Override
-	public void setCatalog(String catalog) throws SQLException {
+	public void setCatalog(String catalog) {
 		// silently ignore this request as MonetDB does not support catalogs
 	}
 	/**
 	 * Changes the default holdability of ResultSet objects created using this
 	 * ResultSet objects can be be determined by invoking DatabaseMetaData.getResultSetHoldability().
 	 *
 	 * @param holdability - a ResultSet holdability constant; one of
 	 *	ResultSet.HOLD_CURSORS_OVER_COMMIT or
 	 *	ResultSet.CLOSE_CURSORS_AT_COMMIT
+	 * @throws SQLException - if a database access error occurs or this method is called on a closed connection
+	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this method or argument
 	 * @see #getHoldability()
 	 */
 	@Override
 	public void setHoldability(int holdability) throws SQLException {
 		// we only support ResultSet.HOLD_CURSORS_OVER_COMMIT
 		if (holdability != ResultSet.HOLD_CURSORS_OVER_COMMIT)
-			throw new SQLFeatureNotSupportedException("setHoldability(CLOSE_CURSORS_AT_COMMIT) not supported", "0A000");
+			throw newSQLFeatureNotSupportedException("setHoldability(CLOSE_CURSORS_AT_COMMIT)");
 	}
 	/**
 	 * Puts this connection in read-only mode as a hint to the driver to
 	 * enable database optimizations.  MonetDB doesn't support any mode
 	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this data type
 	 * @since 1.6
 	 */
 	@Override
 	public java.sql.Array createArrayOf(String typeName, Object[] elements) throws SQLException {
-		throw new SQLFeatureNotSupportedException("createArrayOf() not supported", "0A000");
+		throw newSQLFeatureNotSupportedException("createArrayOf");
 	}
 	/**
 	 * Constructs an object that implements the Clob interface. The
 	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this data type
 	 * @since 1.6
 	 */
 	@Override
 	public java.sql.NClob createNClob() throws SQLException {
-		throw new SQLFeatureNotSupportedException("createNClob() not supported", "0A000");
+		throw newSQLFeatureNotSupportedException("createNClob");
 	}
 	/**
 	 * Factory method for creating Struct objects.
 	 *
 	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this data type
 	 * @since 1.6
 	 */
 	@Override
 	public java.sql.Struct createStruct(String typeName, Object[] attributes) throws SQLException {
-		throw new SQLFeatureNotSupportedException("createStruct() not supported", "0A000");
+		throw newSQLFeatureNotSupportedException("createStruct");
 	}
 	/**
 	 * Constructs an object that implements the SQLXML interface. The
 	 * object returned initially contains no data. The
 	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this data type
 	 * @since 1.6
 	 */
 	@Override
 	public java.sql.SQLXML createSQLXML() throws SQLException {
-		throw new SQLFeatureNotSupportedException("createSQLXML() not supported", "0A000");
+		throw newSQLFeatureNotSupportedException("createSQLXML");
 	}
 	/**
 	 * Returns true if the connection has not been closed and is still
 	 * valid. The driver shall submit a query on the connection or use
 		public abstract void complete() throws SQLException;
 		/**
 		 * Instructs the Response implementation to close and do the
 		 * necessary clean up procedures.
-		 *
-		 * @throws SQLException
 		 */
 		public abstract void close();
 	}
 	// }}}
 		}
 		/**
 		 * Instructs the Response implementation to close and do the
 		 * necessary clean up procedures.
-		 *
-		 * @throws SQLException
 		 */
 		@Override
 		public void close() {
 			// feed all rows to the garbage collector
 			for (int i = 0; i < data.length; i++) data[i] = null;
 		Response getNextResponse() throws SQLException {
 			if (rstype == ResultSet.TYPE_FORWARD_ONLY) {
 				// free resources if we're running forward only
 				if (curResponse >= 0 && curResponse < responses.size()) {
 					Response tmp = responses.get(curResponse);
-					if (tmp != null) tmp.close();
+					if (tmp != null)
+						tmp.close();
 					responses.set(curResponse, null);
 				}
 			}
 			curResponse++;
 			if (curResponse >= responses.size()) {
 		 * Closes the Reponse at index i, if not null.
 		 *
 		 * @param i the index position of the header to close
 		 */
 		void closeResponse(int i) {
-			if (i < 0 || i >= responses.size()) return;
+			if (i < 0 || i >= responses.size())
+				return;
 			Response tmp = responses.set(i, null);
 			if (tmp != null)
 				tmp.close();
 		}

Mercurial > hg > monetdb-java

comparison src/main/java/nl/cwi/monetdb/jdbc/MonetConnection.java @ 262:2d62ca1f758b