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

comparison src/main/java/nl/cwi/monetdb/jdbc/MonetConnection.java @ 77:83aee4f60649

Added private method sendTransactionCommand(String); to reduce duplicate code in 6 methods. Throw a SQLFeatureNotSupportedException for not implemented methods: prepareStatement(String sql, int[] columnIndexes) and prepareStatement(String sql, String[] columnNames). Rest of the changes are only layout and removal of trailing tabs.

author	Martin van Dinther <martin.van.dinther@monetdbsolutions.com>
date	Thu, 15 Dec 2016 15:29:36 +0100 (2016-12-15)
parents	562dbfb2fee8
children	a6608e9581c1

comparison

equal deleted inserted replaced

-:3abb3634f467
+:83aee4f60649
 	 */
 	@Override
 	public void commit() throws SQLException {
 		// note: can't use sendIndependentCommand here because we need
 		// to process the auto_commit state the server gives
+		sendTransactionCommand("COMMIT");
-		// create a container for the result
-		ResponseList l = new ResponseList(
-			0,
-			0,
-			ResultSet.FETCH_FORWARD,
-			ResultSet.CONCUR_READ_ONLY
-		);
-		// send commit to the server
-		try {
-			l.processQuery("COMMIT");
-		} finally {
-			l.close();
-		}
 	}
 	/**
 	 * Creates a Statement object for sending SQL statements to the
 	 * database.  SQL statements without parameters are normally
 	 * @return a new default Statement object
 	 * @throws SQLException if a database access error occurs
 	 */
 	@Override
 	public Statement createStatement() throws SQLException {
-		return createStatement(
+		return createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
-					ResultSet.TYPE_FORWARD_ONLY,
-					ResultSet.CONCUR_READ_ONLY,
-					ResultSet.HOLD_CURSORS_OVER_COMMIT);
 	}
 	/**
 	 * Creates a Statement object that will generate ResultSet objects
 	 * with the given type and concurrency. This method is the same as
 	 * @return a new Statement object that will generate ResultSet objects with
 	 *         the given type and concurrency
 	 * @throws SQLException if a database access error occurs
 	 */
 	@Override
-	public Statement createStatement(
+	public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
-			int resultSetType,
+		return createStatement(resultSetType, resultSetConcurrency, ResultSet.HOLD_CURSORS_OVER_COMMIT);
-			int resultSetConcurrency)
-		throws SQLException
-	{
-		return createStatement(
-					resultSetType,
-					resultSetConcurrency,
-					ResultSet.HOLD_CURSORS_OVER_COMMIT);
 	}
 	/**
 	 * Creates a Statement object that will generate ResultSet objects
 	 * with the given type, concurrency, and holdability.  This method
 	 * @throws SQLException if a database access error occurs or the
 	 * given parameters are not ResultSet constants indicating type,
 	 * concurrency, and holdability
 	 */
 	@Override
-	public Statement createStatement(
+	public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
-			int resultSetType,
-			int resultSetConcurrency,
-			int resultSetHoldability)
-		throws SQLException
-	{
 		try {
-			Statement ret =
+			Statement ret = new MonetStatement(this, resultSetType, resultSetConcurrency, resultSetHoldability);
-				new MonetStatement(
-					this,
-					resultSetType,
-					resultSetConcurrency,
-					resultSetHoldability
-				);
 			// store it in the map for when we close...
 			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
 		// be thrown
 	}
 	/**
-	 * Retrieves the current auto-commit mode for this Connection
+	 * Retrieves the current auto-commit mode for this Connection object.
-	 * object.
+	 *
-	 *
+	 * @return the current state of this Connection object's auto-commit mode
-	 * @return the current state of this Connection object's auto-commit
-	 *         mode
 	 * @see #setAutoCommit(boolean)
 	 */
 	@Override
 	public boolean getAutoCommit() throws SQLException {
 		return autoCommit;
 	@Override
 	public String getCatalog() throws SQLException {
 		// MonetDB does NOT support catalogs
 		return null;
 	}
 	/**
 	 * Retrieves the current holdability of ResultSet objects created
 	 * using this Connection object.
 	 *
 	 * @return the holdability, one of
 	public boolean isReadOnly() {
 		return false;
 	}
 	@Override
-	public String nativeSQL(String sql) {return sql;}
+	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 */
-	@Override
+		/* in future we may replace/remove the escape sequences { <escape-type> ...} before sending it to the server */
-	public CallableStatement prepareCall(String sql) {return null;}
+		return sql;
+	}
-	@Override
-	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) {return null;}
+	@Override
+	public CallableStatement prepareCall(String sql) {
-	@Override
+		/* not implemented yet */
-	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) {return null;}
+		return null;
+	}
+	@Override
+	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) {
+		/* not implemented yet */
+		return null;
+	}
+	@Override
+	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) {
+		/* not implemented yet */
+		return null;
+	}
 	/**
 	 * Creates a PreparedStatement object for sending parameterized SQL
 	 * statements to the database.
 	 *
 	 *         pre-compiled SQL statement
 	 * @throws SQLException if a database access error occurs
 	 */
 	@Override
 	public PreparedStatement prepareStatement(String sql) throws SQLException {
-		return prepareStatement(
+		return prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
-					sql,
-					ResultSet.TYPE_FORWARD_ONLY,
-					ResultSet.CONCUR_READ_ONLY,
-					ResultSet.HOLD_CURSORS_OVER_COMMIT
-		);
 	}
 	/**
 	 * Creates a PreparedStatement object that will generate ResultSet
 	 * objects with the given type and concurrency.  This method is the
 	 * @throws SQLException if a database access error occurs or the given
 	 *                      parameters are not ResultSet constants indicating
 	 *                      type and concurrency
 	 */
 	@Override
-	public PreparedStatement prepareStatement(
+	public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
-			String sql,
+		return prepareStatement(sql, resultSetType, resultSetConcurrency, ResultSet.HOLD_CURSORS_OVER_COMMIT);
-			int resultSetType,
-			int resultSetConcurrency)
-		throws SQLException
-	{
-		return prepareStatement(
-					sql,
-					resultSetType,
-					resultSetConcurrency,
-					ResultSet.HOLD_CURSORS_OVER_COMMIT
-		);
 	}
 	/**
 	 * Creates a PreparedStatement object that will generate ResultSet
 	 * objects with the given type, concurrency, and holdability.
 	 * @throws SQLException if a database access error occurs or the
 	 * given parameters are not ResultSet constants indicating type,
 	 * concurrency, and holdability
 	 */
 	@Override
-	public PreparedStatement prepareStatement(
+	public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
-			String sql,
-			int resultSetType,
-			int resultSetConcurrency,
-			int resultSetHoldability)
 		throws SQLException
 	{
 		try {
 			PreparedStatement ret = new MonetPreparedStatement(
 				this,
 	 * @throws SQLException - if a database access error occurs or the
 	 *         given parameter is not a Statement  constant indicating
 	 *         whether auto-generated keys should be returned
 	 */
 	@Override
-	public PreparedStatement prepareStatement(
+	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
-			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
 		 * thing ;) */
-		return prepareStatement(
+		return prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
-					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.
-	}
+	 * This array contains the indexes of the columns in the target table that contain the auto-generated keys that should be made available.
+	 * The driver will ignore the array if the SQL statement is not an INSERT statement, or an SQL statement able to
-	@Override
+	 * return auto-generated keys (the list of such statements is vendor-specific).
-	public PreparedStatement prepareStatement(String sql, int[] columnIndexes) {return null;}
+	 *
+	 * An SQL statement with or without IN parameters can be pre-compiled and stored in a PreparedStatement object.
-	@Override
+	 * This object can then be used to efficiently execute this statement multiple times.
-	public PreparedStatement prepareStatement(String sql, String[] columnNames) {return null;}
+	 *
+	 * Note: This method is optimized for handling parametric SQL statements that benefit from precompilation.
+	 * If the driver supports precompilation, the method prepareStatement will send the statement to the database for precompilation.
+	 * Some drivers may not support precompilation. In this case, the statement may not be sent to the database until the PreparedStatement
+	 * 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:
+	 *     sql - an SQL statement that may contain one or more '?' IN parameter placeholders
+	 *     columnIndexes - an array of column indexes indicating the columns that should be returned from the inserted row or rows
+	 * Returns:
+	 *     a new PreparedStatement object, containing the pre-compiled statement, that is capable of
+	 *     returning the auto-generated keys designated by the given array of column indexes
+	 * 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");
+	}
+	/**
+	 * 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.
+	 * The driver will ignore the array if the SQL statement is not an INSERT statement, or an SQL statement able to
+	 * return auto-generated keys (the list of such statements is vendor-specific).
+	 *
+	 * An SQL statement with or without IN parameters can be pre-compiled and stored in a PreparedStatement object.
+	 * This object can then be used to efficiently execute this statement multiple times.
+	 *
+	 * Note: This method is optimized for handling parametric SQL statements that benefit from precompilation.
+	 * If the driver supports precompilation, the method prepareStatement will send the statement to the database for precompilation.
+	 * Some drivers may not support precompilation. In this case, the statement may not be sent to the database until the PreparedStatement
+	 * 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:
+	 *     sql - an SQL statement that may contain one or more '?' IN parameter placeholders
+	 *     columnNames - an array of column names indicating the columns that should be returned from the inserted row or rows
+	 * Returns:
+	 *     a new PreparedStatement object, containing the pre-compiled statement, that is capable of
+	 *     returning the auto-generated keys designated by the given array of column names
+	 * 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");
+	}
 	/**
 	 * Removes the given Savepoint object from the current transaction.
 	 * Any reference to the savepoint after it have been removed will
 	 * cause an SQLException to be thrown.
 		MonetSavepoint sp = (MonetSavepoint)savepoint;
 		// note: can't use sendIndependentCommand here because we need
 		// to process the auto_commit state the server gives
+		sendTransactionCommand("RELEASE SAVEPOINT " + sp.getName());
-		// create a container for the result
-		ResponseList l = new ResponseList(
-			0,
-			0,
-			ResultSet.FETCH_FORWARD,
-			ResultSet.CONCUR_READ_ONLY
-		);
-		// send the appropriate query string to the database
-		try {
-			l.processQuery("RELEASE SAVEPOINT " + sp.getName());
-		} finally {
-			l.close();
-		}
 	}
 	/**
 	 * Undoes all changes made in the current transaction and releases
 	 * any database locks currently held by this Connection object.
 	 */
 	@Override
 	public void rollback() throws SQLException {
 		// note: can't use sendIndependentCommand here because we need
 		// to process the auto_commit state the server gives
+		sendTransactionCommand("ROLLBACK");
-		// create a container for the result
-		ResponseList l = new ResponseList(
-			0,
-			0,
-			ResultSet.FETCH_FORWARD,
-			ResultSet.CONCUR_READ_ONLY
-		);
-		// send rollback to the server
-		try {
-			l.processQuery("ROLLBACK");
-		} finally {
-			l.close();
-		}
 	}
 	/**
 	 * Undoes all changes made after the given Savepoint object was set.
 	 *
 		MonetSavepoint sp = (MonetSavepoint)savepoint;
 		// note: can't use sendIndependentCommand here because we need
 		// to process the auto_commit state the server gives
+		sendTransactionCommand("ROLLBACK TO SAVEPOINT " + sp.getName());
-		// create a container for the result
-		ResponseList l = new ResponseList(
-			0,
-			0,
-			ResultSet.FETCH_FORWARD,
-			ResultSet.CONCUR_READ_ONLY
-		);
-		// send the appropriate query string to the database
-		try {
-			l.processQuery("ROLLBACK TO SAVEPOINT " + sp.getName());
-		} finally {
-			l.close();
-		}
 	}
 	/**
 	 * Sets this connection's auto-commit mode to the given state. If a
 	 * connection is in auto-commit mode, then all its SQL statements
 		// create a new Savepoint object
 		MonetSavepoint sp = new MonetSavepoint();
 		// note: can't use sendIndependentCommand here because we need
 		// to process the auto_commit state the server gives
+		sendTransactionCommand("SAVEPOINT " + sp.getName());
-		// create a container for the result
-		ResponseList l = new ResponseList(
-			0,
-			0,
-			ResultSet.FETCH_FORWARD,
-			ResultSet.CONCUR_READ_ONLY
-		);
-		// send the appropriate query string to the database
-		try {
-			l.processQuery("SAVEPOINT " + sp.getName());
-		} finally {
-			l.close();
-		}
 		return sp;
 	}
 	/**
 	 * Creates a savepoint with the given name in the current transaction
 			throw new SQLException(e.getMessage(), "M0M03");
 		}
 		// note: can't use sendIndependentCommand here because we need
 		// to process the auto_commit state the server gives
+		sendTransactionCommand("SAVEPOINT " + sp.getName());
-		// create a container for the result
-		ResponseList l = new ResponseList(
-			0,
-			0,
-			ResultSet.FETCH_FORWARD,
-			ResultSet.CONCUR_READ_ONLY
-		);
-		// send the appropriate query string to the database
-		try {
-			l.processQuery("SAVEPOINT " + sp.getName());
-		} finally {
-			l.close();
-		}
 		return sp;
 	}
 	/**
 	 * Attempts to change the transaction isolation level for this
 	 * @throws SQLFeatureNotSupportedException the JDBC driver does
 	 *         not support this data type
 	 * @since 1.6
 	 */
 	@Override
-	public java.sql.Array createArrayOf(String typeName, Object[] elements)
+	public java.sql.Array createArrayOf(String typeName, Object[] elements) throws SQLException {
-		throws SQLException
-	{
 		throw new SQLFeatureNotSupportedException("createArrayOf() not supported", "0A000");
 	}
 	/**
 	 * @throws SQLFeatureNotSupportedException the JDBC driver does
 	 *         not support this data type
 	 * @since 1.6
 	 */
 	@Override
-	public java.sql.Struct createStruct(String typeName, Object[] attributes)
+	public java.sql.Struct createStruct(String typeName, Object[] attributes) throws SQLException {
-		throws SQLException
-	{
 		throw new SQLFeatureNotSupportedException("createStruct() not supported", "0A000");
 	}
 	/**
 	 * Constructs an object that implements the SQLXML interface. The
 	 *         method is called on a closed connection, the executor is
 	 *         null, or the value specified for seconds is less than 0.
 	 * @since 1.7
 	 */
 	@Override
-	public void setNetworkTimeout(Executor executor, int millis)
+	public void setNetworkTimeout(Executor executor, int millis) throws SQLException {
-		throws SQLException
-	{
 		if (closed)
 			throw new SQLException("Cannot call on closed Connection", "M1M20");
 		if (executor == null)
 			throw new SQLException("executor is null", "M1M05");
 		if (millis < 0)
 	/**
 	 * Returns whether the BLOB type should be mapped to BINARY type.
 	 */
 	boolean getBlobAsBinary() {
 		return blobIsBinary;
+	}
+	/**
+	 * Sends the given string to MonetDB as special transaction command.
+	 * All possible returned information is discarded.
+	 * Encountered errors are reported.
+	 *
+	 * @param command the exact string to send to MonetDB
+	 * @throws SQLException if an IO exception or a database error occurs
+	 */
+	private void sendTransactionCommand(String command) throws SQLException {
+		// create a container for the result
+		ResponseList l = new ResponseList(0, 0, ResultSet.FETCH_FORWARD, ResultSet.CONCUR_READ_ONLY);
+		// send the appropriate query string to the database
+		try {
+			l.processQuery(command);
+		} finally {
+			l.close();
+		}
 	}
 	/**
 	 * Sends the given string to MonetDB as regular statement, making
 	 * sure there is a prompt after the command is sent.  All possible
 		 * @return an array of Strings
 		 */
 		final private String[] getValues(char[] chrLine, int start, int stop) {
 			int elem = 0;
 			String[] values = new String[columncount];
 			for (int i = start; i < stop; i++) {
 				if (chrLine[i] == '\t' && chrLine[i - 1] == ',') {
 					values[elem++] =
 						new String(chrLine, start, i - 1 - start);
 					start = i + 1;
 		boolean isClosed() {
 			return closed;
 		}
 	}
 	// }}}
 	/**
 	 * The DataBlockResponse is tabular data belonging to a
 	 * ResultSetResponse.  Tabular data from the server typically looks
 	 * like:
 	 * <pre>
 	 */
 	// {{{ UpdateResponse class implementation
 	static class UpdateResponse implements Response {
 		public final int count;
 		public final String lastid;
 		public UpdateResponse(int cnt, String id) {
 			// fill the blank finals
 			this.count = cnt;
 			this.lastid = id;
 		}
 	 * <tt>&amp;3</tt>
 	 */
 	// {{{ SchemaResponse class implementation
 	class SchemaResponse implements Response {
 		public final int state = Statement.SUCCESS_NO_INFO;
 		@Override
 		public String addLine(String line, int linetype) {
 			return "Header lines are not supported for a SchemaResponse";
 		}
 	 * <tt>&amp;4 (t|f)</tt>
 	 */
 	// {{{ AutoCommitResponse class implementation
 	class AutoCommitResponse extends SchemaResponse {
 		public final boolean autocommit;
 		public AutoCommitResponse(boolean ac) {
 			// fill the blank final
 			this.autocommit = ac;
 		}
 	}
 		private String[] templ;
 		private String query;
 		private BufferedMCLWriter out;
 		private String error;
 		private int state = WAIT;
 		final Lock sendLock = new ReentrantLock();
 		final Condition queryAvailable = sendLock.newCondition();
 		final Condition waiting = sendLock.newCondition();
 		/**

Mercurial > hg > monetdb-java

comparison src/main/java/nl/cwi/monetdb/jdbc/MonetConnection.java @ 77:83aee4f60649