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

comparison src/main/java/nl/cwi/monetdb/jdbc/MonetConnection.java @ 295:003ae6d881db

Add "final" keyword to method arguments and local variables where possible. It discovered some bugs in the MonetStatement constructor (changed the argument instead of object variable) which are fixed now. See also https://en.wikipedia.org/wiki/Final_(Java)

author	Martin van Dinther <martin.van.dinther@monetdbsolutions.com>
date	Thu, 01 Aug 2019 20:18:43 +0200 (2019-08-01)
parents	b127164342c4
children	c5efd6e661e5

comparison

equal deleted inserted replaced

-:894abb249de1
+:003ae6d881db
 import java.io.File;
 import java.io.IOException;
 import java.net.SocketException;
 import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
 import java.sql.CallableStatement;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.Savepoint;
 import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Properties;
 import java.util.WeakHashMap;
 import java.util.concurrent.Executor;
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-import nl.cwi.monetdb.jdbc.types.INET;
-import nl.cwi.monetdb.jdbc.types.URL;
-import nl.cwi.monetdb.mcl.MCLException;
 import nl.cwi.monetdb.mcl.io.BufferedMCLReader;
 import nl.cwi.monetdb.mcl.io.BufferedMCLWriter;
 import nl.cwi.monetdb.mcl.net.MapiSocket;
 import nl.cwi.monetdb.mcl.parser.HeaderLineParser;
 import nl.cwi.monetdb.mcl.parser.MCLParseException;
 * The current state of this connection is that it nearly implements the
 * whole Connection interface.
 *
 * @author Fabian Groffen
 * @author Martin van Dinther
-* @version 1.3
+* @version 1.4
 */
 public class MonetConnection
 	extends MonetWrapper
 	implements Connection, AutoCloseable
 {
 	/** The Reader from the server */
 	private final BufferedMCLReader in;
 	/** The Writer to the server */
 	private final BufferedMCLWriter out;
-	/** A StartOfHeaderParser  declared for reuse. */
+	/** A StartOfHeaderParser declared for reuse. */
 	private StartOfHeaderParser sohp = new StartOfHeaderParser();
 	/** Whether this Connection is closed (and cannot be used anymore) */
 	private boolean closed;
 	/** The Connection specific mapping of user defined types to Java types */
 	private Map<String,Class<?>> typeMap = new HashMap<String,Class<?>>() {
 		private static final long serialVersionUID = 1L;
 		{
-			put("inet", INET.class);
+			put("inet", nl.cwi.monetdb.jdbc.types.INET.class);
-			put("url",  URL.class);
+			put("url",  nl.cwi.monetdb.jdbc.types.URL.class);
 		}
 	};
 	// See javadoc for documentation about WeakHashMap if you don't know what
 	// it does !!!NOW!!! (only when you deal with it of course)
 	/** A Map containing all (active) Statements created from this Connection */
-	private Map<Statement,?> statements = new WeakHashMap<Statement, Object>();
+	private WeakHashMap<Statement,?> statements = new WeakHashMap<Statement, Object>();
 	/** The number of results we receive from the server at once */
 	private int curReplySize = -1;	// the server by default uses -1 (all)
 	/** A template to apply to each query (like pre and post fixes), filled in constructor */
 	 *
 	 * @param props a Property hashtable holding the properties needed for connecting
 	 * @throws SQLException if a database error occurs
 	 * @throws IllegalArgumentException is one of the arguments is null or empty
 	 */
-	MonetConnection(Properties props)
+	MonetConnection(final Properties props)
 		throws SQLException, IllegalArgumentException
 	{
 	// for debug: System.out.println("New connection object. Received properties are: " + props.toString());
 		// get supported property values from the props argument.
 		// When a value is found add it to the internal conn_props list for use by getClientInfo().
 		this.hostname = props.getProperty("host");
 		if (this.hostname != null)
 			conn_props.setProperty("host", this.hostname);
-		String port_prop = props.getProperty("port");
+		final String port_prop = props.getProperty("port");
 		if (port_prop != null) {
 			try {
 				this.port = Integer.parseInt(port_prop);
 			} catch (NumberFormatException e) {
 				addWarning("Unable to parse port number from: " + port_prop, "M1M05");
 		if (debug_prop != null) {
 			debug = Boolean.parseBoolean(debug_prop);
 			conn_props.setProperty("debug", Boolean.toString(debug));
 		}
-		String hash = props.getProperty("hash");
+		final String hash = props.getProperty("hash");
 		if (hash != null)
 			conn_props.setProperty("hash", hash);
-		String treatBlobAsVarBinary_prop = props.getProperty("treat_blob_as_binary");
+		final String treatBlobAsVarBinary_prop = props.getProperty("treat_blob_as_binary");
 		if (treatBlobAsVarBinary_prop != null) {
 			treatBlobAsVarBinary = Boolean.parseBoolean(treatBlobAsVarBinary_prop);
 			conn_props.setProperty("treat_blob_as_binary", Boolean.toString(treatBlobAsVarBinary));
 			if (treatBlobAsVarBinary)
 				typeMap.put("blob", Byte[].class);
 		}
-		String treatClobAsVarChar_prop = props.getProperty("treat_clob_as_varchar");
+		final String treatClobAsVarChar_prop = props.getProperty("treat_clob_as_varchar");
 		if (treatClobAsVarChar_prop != null) {
 			treatClobAsVarChar = Boolean.parseBoolean(treatClobAsVarChar_prop);
 			conn_props.setProperty("treat_clob_as_varchar", Boolean.toString(treatClobAsVarChar));
 			if (treatClobAsVarChar)
 				typeMap.put("clob", String.class);
 		}
 		int sockTimeout = 0;
-		String so_timeout_prop = props.getProperty("so_timeout");
+		final String so_timeout_prop = props.getProperty("so_timeout");
 		if (so_timeout_prop != null) {
 			try {
 				sockTimeout = Integer.parseInt(so_timeout_prop);
 				if (sockTimeout < 0) {
 					addWarning("Negative socket timeout not allowed. Value ignored", "M1M05");
 		server.setLanguage(language);
 		// we're debugging here... uhm, should be off in real life
 		if (debug) {
 			try {
-				String fname = props.getProperty("logfile", "monet_" + System.currentTimeMillis() + ".log");
+				final String fname = props.getProperty("logfile", "monet_" + System.currentTimeMillis() + ".log");
 				File f = new File(fname);
 				int ext = fname.lastIndexOf('.');
 				if (ext < 0)
 					ext = fname.length();
-				String pre = fname.substring(0, ext);
+				final String pre = fname.substring(0, ext);
-				String suf = fname.substring(ext);
+				final String suf = fname.substring(ext);
 				for (int i = 1; f.exists(); i++) {
 					f = new File(pre + "-" + i + suf);
 				}
 				throw new SQLNonTransientConnectionException("Opening logfile failed: " + ex.getMessage(), "08M01");
 			}
 		}
 		try {
-			List<String> warnings = server.connect(hostname, port, username, password);
+			final java.util.List<String> warnings = server.connect(hostname, port, username, password);
 			for (String warning : warnings) {
 				addWarning(warning, "01M02");
 			}
 			// apply NetworkTimeout value from legacy (pre 4.1) driver
 			server.setSoTimeout(sockTimeout);
 			in = server.getReader();
 			out = server.getWriter();
-			String error = in.waitForPrompt();
+			final String error = in.waitForPrompt();
 			if (error != null)
 				throw new SQLNonTransientConnectionException((error.length() > 6) ? error.substring(6) : error, "08001");
-		} catch (UnknownHostException e) {
+		} catch (java.net.UnknownHostException e) {
 			throw new SQLNonTransientConnectionException("Unknown Host (" + hostname + "): " + e.getMessage(), "08006");
 		} catch (IOException e) {
 			throw new SQLNonTransientConnectionException("Unable to connect (" + hostname + ":" + port + "): " + e.getMessage(), "08006");
 		} catch (MCLParseException e) {
 			throw new SQLNonTransientConnectionException(e.getMessage(), "08001");
-		} catch (MCLException e) {
+		} catch (nl.cwi.monetdb.mcl.MCLException e) {
-			String[] connex = e.getMessage().split("\n");
+			final String[] connex = e.getMessage().split("\n");
-			SQLException sqle = new SQLNonTransientConnectionException(connex[0], "08001", e);
+			final SQLException sqle = new SQLNonTransientConnectionException(connex[0], "08001", e);
 			for (int i = 1; i < connex.length; i++) {
 				sqle.setNextException(new SQLNonTransientConnectionException(connex[1], "08001"));
 			}
 			throw sqle;
 		}
 		if (lang == LANG_SQL) {
 			// enable auto commit
 			setAutoCommit(true);
 			// set our time zone on the server
-			Calendar cal = Calendar.getInstance();
+			final Calendar cal = Calendar.getInstance();
 			int offset = cal.get(Calendar.ZONE_OFFSET) + cal.get(Calendar.DST_OFFSET);
 			offset /= (60 * 1000); // milliseconds to minutes
 			String tz = offset < 0 ? "-" : "+";
 			tz += (Math.abs(offset) / 60 < 10 ? "0" : "") + (Math.abs(offset) / 60) + ":";
 			offset -= (offset / 60) * 60;
 	 * @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(int resultSetType, int resultSetConcurrency) throws SQLException {
+	public Statement createStatement(final int resultSetType, final int resultSetConcurrency) throws SQLException {
 		return createStatement(resultSetType, resultSetConcurrency, MonetResultSet.DEF_HOLDABILITY);
 	}
 	/**
 	 * Creates a Statement object that will generate ResultSet objects
 	 * @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(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
+	public Statement createStatement(final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) throws SQLException {
 		try {
-			Statement ret = new MonetStatement(this, resultSetType, resultSetConcurrency, resultSetHoldability);
+			final Statement ret = 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");
 	 *
 	 * @param sql - an SQL statement that may contain one or more '?' parameter placeholders.
 	 * @return the native form of this statement
 	 */
 	@Override
-	public String nativeSQL(String sql) {
+	public String nativeSQL(final 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 */
 		return sql;
 	}
 	 *
 	 * @param sql - an SQL statement that may contain one or more '?' parameter placeholders.
 	 *	Typically this statement is specified using JDBC call escape syntax.
 	 * @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 SQLFeatureNotSupportedException - if the JDBC driver does not support this method.
+	 */
-	 */
+	@Override
-	@Override
+	public CallableStatement prepareCall(final String sql) throws SQLException {
-	public CallableStatement prepareCall(String sql) throws SQLException {
 		return prepareCall(sql, MonetResultSet.DEF_RESULTSETTYPE, MonetResultSet.DEF_CONCURRENCY, MonetResultSet.DEF_HOLDABILITY);
 	}
 	/**
 	 * Creates a CallableStatement object that will generate ResultSet objects with the given type and concurrency.
 	 * @param resultSetConcurrency - a concurrency type; one of ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
 	 * @return a new CallableStatement object containing the pre-compiled SQL statement that
 	 *	will produce ResultSet objects with the given type and concurrency
 	 * @throws 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
-	 * @throws 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.
+	@Override
-	 */
+	public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency) throws SQLException {
-	@Override
-	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
 		return prepareCall(sql, resultSetType, resultSetConcurrency, MonetResultSet.DEF_HOLDABILITY);
 	}
 	/**
 	 * Creates a CallableStatement object that will generate ResultSet objects with the given type and concurrency.
 	 * @param resultSetConcurrency - a concurrency type; one of ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
 	 * @param resultSetHoldability - one of the following ResultSet constants: ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
 	 * @return a new CallableStatement object, containing the pre-compiled SQL statement, that will generate ResultSet objects with the given type, concurrency, and holdability
 	 * @throws 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
-	 * @throws 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.
+	@Override
-	 */
+	public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability)
-	@Override
-	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
 		throws SQLException
 	{
 		try {
-			CallableStatement ret = new MonetCallableStatement(
+			final CallableStatement ret = new MonetCallableStatement(
 				this,
 				resultSetType,
 				resultSetConcurrency,
 				resultSetHoldability,
 				sql
 	 * @return a new default PreparedStatement object containing the
 	 *         pre-compiled SQL statement
 	 * @throws SQLException if a database access error occurs
 	 */
 	@Override
-	public PreparedStatement prepareStatement(String sql) throws SQLException {
+	public PreparedStatement prepareStatement(final String sql) throws SQLException {
 		return prepareStatement(sql, MonetResultSet.DEF_RESULTSETTYPE, MonetResultSet.DEF_CONCURRENCY, MonetResultSet.DEF_HOLDABILITY);
 	}
 	/**
 	 * Creates a PreparedStatement object that will generate ResultSet
 	 * @throws SQLException if a database access error occurs or the given
 	 *         parameters are not ResultSet constants indicating
 	 *         type and concurrency
 	 */
 	@Override
-	public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+	public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency) throws SQLException {
 		return prepareStatement(sql, resultSetType, resultSetConcurrency, MonetResultSet.DEF_HOLDABILITY);
 	}
 	/**
 	 * Creates a PreparedStatement object that will generate ResultSet
 	 * @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(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
+	public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability)
 		throws SQLException
 	{
 		try {
-			PreparedStatement ret = new MonetPreparedStatement(
+			final PreparedStatement ret = new MonetPreparedStatement(
 				this,
 				resultSetType,
 				resultSetConcurrency,
 				resultSetHoldability,
 				sql
 	 * @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(String sql, int autoGeneratedKeys) throws SQLException {
+	public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
 		if (autoGeneratedKeys != Statement.RETURN_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 ;) */
 	 * 	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
 	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this method
 	 */
 	@Override
-	public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
+	public PreparedStatement prepareStatement(final String sql, final int[] columnIndexes) throws SQLException {
 		throw newSQLFeatureNotSupportedException("prepareStatement(String sql, int[] columnIndexes)");
 	}
 	/**
 	 * Creates a default PreparedStatement object capable of returning the auto-generated keys designated by the given array.
 	 * 	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
 	 * @throws SQLFeatureNotSupportedException - if the JDBC driver does not support this method
 	 */
 	@Override
-	public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
+	public PreparedStatement prepareStatement(final String sql, final String[] columnNames) throws SQLException {
 		throw newSQLFeatureNotSupportedException("prepareStatement(String sql, String[] columnNames)");
 	}
 	/**
 	 * Removes the given Savepoint object from the current transaction.
 	 * @throws SQLException if a database access error occurs or the given
 	 *         Savepoint object is not a valid savepoint in the current
 	 *         transaction
 	 */
 	@Override
-	public void releaseSavepoint(Savepoint savepoint) throws SQLException {
+	public void releaseSavepoint(final Savepoint savepoint) throws SQLException {
 		if (!(savepoint instanceof MonetSavepoint))
 			throw new SQLException("This driver can only handle savepoints it created itself", "M0M06");
-		MonetSavepoint sp = (MonetSavepoint)savepoint;
+		final 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());
 	}
 	 * @throws SQLException if a database access error occurs, the
 	 *         Savepoint object is no longer valid, or this Connection
 	 *         object is currently in auto-commit mode
 	 */
 	@Override
-	public void rollback(Savepoint savepoint) throws SQLException {
+	public void rollback(final Savepoint savepoint) throws SQLException {
 		if (!(savepoint instanceof MonetSavepoint))
 			throw new SQLException("This driver can only handle savepoints it created itself", "M0M06");
-		MonetSavepoint sp = (MonetSavepoint)savepoint;
+		final 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());
 	}
 	 * @param autoCommit true to enable auto-commit mode; false to disable it
 	 * @throws SQLException if a database access error occurs
 	 * @see #getAutoCommit()
 	 */
 	@Override
-	public void setAutoCommit(boolean autoCommit) throws SQLException {
+	public void setAutoCommit(final boolean autoCommit) throws SQLException {
 		if (this.autoCommit != autoCommit) {
 			sendControlCommand("auto_commit " + (autoCommit ? "1" : "0"));
 			this.autoCommit = autoCommit;
 		}
 	}
 	 * 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) {
+	public void setCatalog(final String catalog) {
 		// silently ignore this request as MonetDB does not support catalogs
 	}
 	/**
 	 * Changes the default holdability of ResultSet objects created using this
 	 * @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 {
+	public void setHoldability(final int holdability) throws SQLException {
 		// we only support ResultSet.HOLD_CURSORS_OVER_COMMIT
 		if (holdability != ResultSet.HOLD_CURSORS_OVER_COMMIT)
 			throw newSQLFeatureNotSupportedException("setHoldability(CLOSE_CURSORS_AT_COMMIT)");
 	}
 	 * @param readOnly true enables read-only mode; false disables it
 	 * @throws SQLException if a database access error occurs or this
 	 *         method is called during a transaction.
 	 */
 	@Override
-	public void setReadOnly(boolean readOnly) throws SQLException {
+	public void setReadOnly(final boolean readOnly) throws SQLException {
 		if (readOnly == true)
 			addWarning("cannot setReadOnly(true): read-only Connection mode not supported", "01M08");
 	}
 	/**
 	 *         object is currently in auto-commit mode
 	 */
 	@Override
 	public Savepoint setSavepoint() throws SQLException {
 		// create a new Savepoint object
-		MonetSavepoint sp = new MonetSavepoint();
+		final 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());
 		return sp;
 	 * @return the new Savepoint object
 	 * @throws SQLException if a database access error occurs or this Connection
 	 *         object is currently in auto-commit mode
 	 */
 	@Override
-	public Savepoint setSavepoint(String name) throws SQLException {
+	public Savepoint setSavepoint(final String name) throws SQLException {
 		// create a new Savepoint object
-		MonetSavepoint sp;
+		final MonetSavepoint sp;
 		try {
 			sp = new MonetSavepoint(name);
 		} catch (IllegalArgumentException e) {
 			throw new SQLException(e.getMessage(), "M0M03");
 		}
 	 *        Connection.TRANSACTION_READ_COMMITTED,
 	 *        Connection.TRANSACTION_REPEATABLE_READ, or
 	 *        Connection.TRANSACTION_SERIALIZABLE.
 	 */
 	@Override
-	public void setTransactionIsolation(int level) {
+	public void setTransactionIsolation(final int level) {
 		if (level != TRANSACTION_SERIALIZABLE) {
 			addWarning("MonetDB only supports fully serializable " +
 				"transactions, continuing with transaction level " +
 				"raised to TRANSACTION_SERIALIZABLE", "01M09");
 		}
 	 *
 	 * @param map the java.util.Map object to install as the replacement for
 	 *        this Connection  object's default type map
 	 */
 	@Override
-	public void setTypeMap(Map<String, Class<?>> map) {
+	public void setTypeMap(final Map<String, Class<?>> map) {
 		typeMap = map;
 	}
 	/**
 	 * Returns a string identifying this Connection to the MonetDB server.
 	 *         the conversion is not supported, the typeName is null or this method is called on a closed connection
 	 * @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 {
+	public java.sql.Array createArrayOf(final String typeName, final Object[] elements) throws SQLException {
 		throw newSQLFeatureNotSupportedException("createArrayOf");
 	}
 	/**
 	 *         this method is called on a closed connection or a database access error occurs.
 	 * @since 1.6
 	 */
 	@Override
 	public java.sql.Blob createBlob() throws SQLException {
-		byte[] buf = new byte[1];
+		return new MonetBlob(new byte[1]);
-		return new MonetBlob(buf);
 	}
 	/**
 	 * Constructs an object that implements the NClob interface. The
 	 * object returned initially contains no data. The setAsciiStream,
 	 * @return true if the connection is valid, false otherwise
 	 * @throws SQLException if the value supplied for timeout is less than 0
 	 * @since 1.6
 	 */
 	@Override
-	public boolean isValid(int timeout) throws SQLException {
+	public boolean isValid(final int timeout) throws SQLException {
 		if (timeout < 0)
 			throw new SQLException("timeout is less than 0", "M1M05");
 		if (closed)
 			return false;
 		ResultSet rs = null;
 		boolean isValid = false;
 		try {
 			stmt = createStatement();
 			if (stmt != null) {
-				int original_timeout = stmt.getQueryTimeout();
+				final int original_timeout = stmt.getQueryTimeout();
 				if (timeout > 0 && original_timeout != timeout) {
 					// we need to change the requested timeout for this test query
 					stmt.setQueryTimeout(timeout);
 				}
 				rs = stmt.executeQuery("SELECT 1");
 	 *	when fetching the client info value from the database
 	 *	or this method is called on a closed connection
 	 * @since 1.6
 	 */
 	@Override
-	public String getClientInfo(String name) throws SQLException {
+	public String getClientInfo(final String name) throws SQLException {
 		if (name == null || name.isEmpty())
 			return null;
 		return conn_props.getProperty(name);
 	}
 	 *         while setting the clientInfo values on the database server
 	 *         or this method is called on a closed connection
 	 * @since 1.6
 	 */
 	@Override
-	public void setClientInfo(String name, String value) throws SQLClientInfoException {
+	public void setClientInfo(final String name, final String value) throws SQLClientInfoException {
 		if (name == null || name.isEmpty()) {
 			addWarning("setClientInfo: missing property name", "01M07");
 			return;
 		}
 		// If the value is null, the current value of the specified property is cleared.
 		{
 			conn_props.setProperty(name, value);
 		} else {
 			addWarning("setClientInfo: " + name + "is not a recognised property", "01M07");
 		}
-		return;
 	}
 	/**
 	 * Sets the value of the connection's client info properties.
 	 * The Properties object contains the names and values of the client info
 	 *	while setting the clientInfo values on the database server
 	 *	or this method is called on a closed connection
 	 * @since 1.6
 	 */
 	@Override
-	public void setClientInfo(Properties props) throws SQLClientInfoException {
+	public void setClientInfo(final Properties props) throws SQLClientInfoException {
 		if (props != null) {
 			for (Entry<Object, Object> entry : props.entrySet()) {
-				setClientInfo(entry.getKey().toString(),
+				setClientInfo(entry.getKey().toString(), entry.getValue().toString());
-						entry.getValue().toString());
 			}
 		}
 	}
 	 * @throws SQLException if a database access error occurs or this
 	 *         method is called on a closed connection
 	 * @since 1.7
 	 */
 	@Override
-	public void setSchema(String schema) throws SQLException {
+	public void setSchema(final String schema) throws SQLException {
 		if (closed)
 			throw new SQLException("Cannot call on closed Connection", "M1M20");
 		if (schema == null || schema.isEmpty())
 			throw new SQLException("Missing schema name", "M1M05");
 	 * @throws SecurityException if a security manager exists and
 	 *         its checkPermission method denies calling abort
 	 * @since 1.7
 	 */
 	@Override
-	public void abort(Executor executor) throws SQLException {
+	public void abort(final Executor executor) throws SQLException {
 		if (closed)
 			return;
 		if (executor == null)
 			throw new SQLException("executor is null", "M1M05");
 		// this is really the simplest thing to do, it destroys
 	 *         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) throws SQLException {
+	public void setNetworkTimeout(final Executor executor, final int millis) 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)
 	/**
 	 * @return the MonetDB JDBC Connection URL (without user name and password).
 	 * Defined as public because it is called from: MonetDatabaseMetaData.java getURL()
 	 */
 	String getJDBCURL() {
-		String language = "";
+		return MonetDriver.MONETURL + hostname + ":" + port + "/" + database + (lang == LANG_MAL ? "?language=mal" : "");
-		if (lang == LANG_MAL)
-			language = "?language=mal";
-		return MonetDriver.MONETURL + hostname + ":" + port + "/" + database + language;
 	}
 	/**
 	 * @return whether the JDBC BLOB type should be mapped to VARBINARY type.
 	 * This allows generic JDBC programs to fetch Blob data via getBytes()
 	}
 	/**
 	 * Internal utility method to query the server to find out if it has the system table sys.<tablename>.
 	 */
-	private boolean existsSysTable(String tablename) {
+	private boolean existsSysTable(final String tablename) {
 		boolean exists = false;
 		Statement stmt = null;
 		ResultSet rs = null;
 		try {
 			stmt = createStatement();
 	 * 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 {
+	private void sendTransactionCommand(final String command) throws SQLException {
 		// create a container for the result
-		ResponseList l = new ResponseList(0, 0, ResultSet.FETCH_FORWARD, ResultSet.CONCUR_READ_ONLY);
+		final 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();
 	 *
 	 * @param command the exact string to send to MonetDB
 	 * @param usequeryTempl send the command using a queryTempl? else it is send using commandTempl
 	 * @throws SQLException if an IO exception or a database error occurs
 	 */
-	private void sendCommand(String command, boolean usequeryTempl) throws SQLException {
+	private void sendCommand(final String command, final boolean usequeryTempl) throws SQLException {
-		String cmd = usequeryTempl ?
+		final String cmd = usequeryTempl
-			(queryTempl[0] == null ? "" : queryTempl[0]) + command + (queryTempl[1] == null ? "" : queryTempl[1])
+			? (queryTempl[0] == null ? "" : queryTempl[0]) + command + (queryTempl[1] == null ? "" : queryTempl[1])
-			:
+			: (commandTempl[0] == null ? "" : commandTempl[0]) + command + (commandTempl[1] == null ? "" : commandTempl[1]);
-			(commandTempl[0] == null ? "" : commandTempl[0]) + command + (commandTempl[1] == null ? "" : commandTempl[1]);
 		synchronized (server) {
 			try {
 				out.writeLine(cmd);
-				String error = in.waitForPrompt();
+				final String error = in.waitForPrompt();
 				if (error != null)
 					throw new SQLException(error.substring(6), error.substring(0, 5));
 			} catch (SocketTimeoutException e) {
 				close(); // JDBC 4.1 semantics, abort()
 				throw new SQLNonTransientConnectionException("connection timed out", "08M33");
 	 * this warning will be the first, otherwise this warning will get
 	 * appended to the current warning.
 	 *
 	 * @param reason the warning message
 	 */
-	void addWarning(String reason, String sqlstate) {
+	private final void addWarning(final String reason, final String sqlstate) {
-		SQLWarning warng = new SQLWarning(reason, sqlstate);
+		final SQLWarning warng = new SQLWarning(reason, sqlstate);
 		if (warnings == null) {
 			warnings = warng;
 		} else {
 			warnings.setNextWarning(warng);
 		}
 		private boolean closed;
 		/** The Connection that we should use when requesting a new block */
 		private final MonetConnection.ResponseList parent;
 		/** Whether the fetchSize was explitly set by the user */
-		private boolean cacheSizeSetExplicitly = false;
+		private final boolean cacheSizeSetExplicitly;
 		/** Whether we should send an Xclose command to the server
 		 *  if we close this Response */
 		private boolean destroyOnClose;
 		/** the offset to be used on Xexport queries */
 		private int blockOffset = 0;
 		/** A parser for header lines */
-		HeaderLineParser hlp;
+		private final HeaderLineParser hlp;
 		/** A boolean array telling whether the headers are set or not */
 		private final boolean[] isSet;
 		private static final int NAMES	= 0;
 		private static final int TYPES	= 1;
 		 * @param parent the parent that created this Response and will
 		 *        supply new result blocks when necessary
 		 * @param seq the query sequence number
 		 */
 		ResultSetResponse(
-				int id,
+				final int id,
-				int tuplecount,
+				final int tuplecount,
-				int columncount,
+				final int columncount,
-				int rowcount,
+				final int rowcount,
-				MonetConnection.ResponseList parent,
+				final MonetConnection.ResponseList parent,
-				int seq)
+				final int seq)
 			throws SQLException
 		{
 			isSet = new boolean[4];
 			this.parent = parent;
 			if (parent.cachesize == 0) {
 		 * @return a non-null String if the header cannot be parsed or
 		 *         is unknown
 		 */
 		// {{{ addLine
 		@Override
-		public String addLine(String tmpLine, int linetype) {
+		public String addLine(final String tmpLine, final int linetype) {
 			if (isSet[LENS] && isSet[TYPES] && isSet[TABLES] && isSet[NAMES]) {
 				return resultBlocks[0].addLine(tmpLine, linetype);
 			}
 			if (linetype != BufferedMCLReader.HEADER)
 		 * @param chrLine a character array holding the input data
 		 * @param start where the relevant data starts
 		 * @param stop where the relevant data stops
 		 * @return an array of Strings
 		 */
-		private final String[] getValues(char[] chrLine, int start, int stop) {
+		private final String[] getValues(final char[] chrLine, int start, final int stop) {
 			int elem = 0;
-			String[] values = new String[columncount];
+			final 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);
 		 * the given block position.
 		 *
 		 * @param offset the offset number of rows for this block
 		 * @param rr the DataBlockResponse to add
 		 */
-		void addDataBlockResponse(int offset, DataBlockResponse rr) {
+		void addDataBlockResponse(final int offset, final DataBlockResponse rr) {
-			int block = (offset - blockOffset) / cacheSize;
+			final int block = (offset - blockOffset) / cacheSize;
 			resultBlocks[block] = rr;
 		}
 		/**
 		 * Marks this Response as being completed.  A complete Response
 		 * @throws SQLException if the data currently in this Response is not
 		 *         sufficient to be consistant
 		 */
 		@Override
 		public void complete() throws SQLException {
-			String error = "";
+			final StringBuilder err = new StringBuilder(99);
-			if (!isSet[NAMES])  error = "name header missing\n";
+			if (!isSet[NAMES])  err.append("name header missing\n");
-			if (!isSet[TYPES])  error += "type header missing\n";
+			if (!isSet[TYPES])  err.append("type header missing\n");
-			if (!isSet[TABLES]) error += "table name header missing\n";
+			if (!isSet[TABLES]) err.append("table name header missing\n");
-			if (!isSet[LENS])   error += "column width header missing\n";
+			if (!isSet[LENS])   err.append("column width header missing\n");
-			if (!error.isEmpty())
+			if (err.length() > 0)
-				throw new SQLException(error, "M0M10");
+				throw new SQLException(err.toString(), "M0M10");
 		}
 		/**
 		 * Returns the names of the columns
 		 *
 		 * @param row the row in the result set to return
 		 * @return the exact row read as requested or null if the requested row
 		 *         is out of the scope of the result set
 		 * @throws SQLException if an database error occurs
 		 */
-		String getLine(int row) throws SQLException {
+		String getLine(final int row) throws SQLException {
 			if (row >= tuplecount || row < 0)
 				return null;
 			int block = (row - blockOffset) / cacheSize;
 			int blockLine = (row - blockOffset) % cacheSize;
 		private final String[] data;
 		/** The counter which keeps the current position in the data array */
 		private int pos;
 		/** Whether we can discard lines as soon as we have read them */
-		private boolean forwardOnly;
+		private final boolean forwardOnly;
 		/**
 		 * Constructs a DataBlockResponse object
 		 * @param size the size of the data array to create
 		 * @param forward whether this is a forward only result
 		 */
-		DataBlockResponse(int size, boolean forward) {
+		DataBlockResponse(final int size, final boolean forward) {
 			pos = -1;
 			data = new String[size];
 			forwardOnly = forward;
 		}
 		 * @param linetype the line type according to the MAPI protocol
 		 * @return a non-null String if the line is invalid,
 		 *         or additional lines are not allowed.
 		 */
 		@Override
-		public String addLine(String line, int linetype) {
+		public String addLine(final String line, final int linetype) {
 			if (linetype != BufferedMCLReader.RESULT)
 				return "protocol violation: unexpected line in data block: " + line;
 			// add to the backing array
 			data[++pos] = line;
 		 * @throws SQLException if not all rows are filled
 		 */
 		@Override
 		public void complete() throws SQLException {
 			if ((pos + 1) != data.length)
-				throw new SQLException("Inconsistent state detected!  Current block capacity: "
+				throw new SQLException("Inconsistent state detected! Current block capacity: "
-					+ data.length + ", block usage: " + (pos + 1) + ".  Did MonetDB send what it promised to?", "M0M10");
+					+ data.length + ", block usage: " + (pos + 1)
+					+ ". Did MonetDB send what it promised to?", "M0M10");
 		}
 		/**
 		 * Instructs the Response implementation to close and do the
 		 * necessary clean up procedures.
 		 */
 		@Override
 		public void close() {
 			// feed all rows to the garbage collector
-			for (int i = 0; i < data.length; i++) data[i] = null;
+			for (int i = 0; i < data.length; i++)
+				data[i] = null;
 		}
 		/**
 		 * Retrieves the required row.  Warning: if the requested rows
 		 * is out of bounds, an IndexOutOfBoundsException will be
 		 * thrown.
 		 *
 		 * @param line the row to retrieve
 		 * @return the requested row as String
 		 */
-		String getRow(int line) {
+		String getRow(final int line) {
 			if (forwardOnly) {
-				String ret = data[line];
+				final String ret = data[line];
 				data[line] = null;
 				return ret;
 			} else {
 				return data[line];
 			}
 	// {{{ UpdateResponse class implementation
 	static class UpdateResponse implements Response {
 		public final int count;
 		public final String lastid;
-		public UpdateResponse(int cnt, String id) {
+		public UpdateResponse(final int cnt, final String id) {
 			// fill the blank finals
 			this.count = cnt;
 			this.lastid = id;
 		}
 		@Override
-		public String addLine(String line, int linetype) {
+		public String addLine(final String line, final int linetype) {
 			return "Header lines are not supported for an UpdateResponse";
 		}
 		@Override
 		public boolean wantsMore() {
 	// {{{ SchemaResponse class implementation
 	class SchemaResponse implements Response {
 		public final int state = Statement.SUCCESS_NO_INFO;
 		@Override
-		public String addLine(String line, int linetype) {
+		public String addLine(final String line, final int linetype) {
 			return "Header lines are not supported for a SchemaResponse";
 		}
 		@Override
 		public boolean wantsMore() {
 	 */
 	// {{{ AutoCommitResponse class implementation
 	class AutoCommitResponse extends SchemaResponse {
 		public final boolean autocommit;
-		public AutoCommitResponse(boolean ac) {
+		public AutoCommitResponse(final boolean ac) {
 			// fill the blank final
 			this.autocommit = ac;
 		}
 	}
 	// }}}
 		private final int rsconcur;
 		/** The sequence number of this ResponseList */
 		private final int seqnr;
 		/** A list of the Responses associated with the query,
 		 *  in the right order */
-		private List<Response> responses;
+		private final ArrayList<Response> responses;
 		/** A map of ResultSetResponses, used for additional
 		 *  DataBlockResponse mapping */
-		private Map<Integer, ResultSetResponse> rsresponses;
+		private HashMap<Integer, ResultSetResponse> rsresponses;
 		/** The current header returned by getNextResponse() */
 		private int curResponse;
 		/**
 		 * @param maxrows maximum number of rows to allow in the set
 		 * @param rstype the type of result sets to produce
 		 * @param rsconcur the concurrency of result sets to produce
 		 */
 		ResponseList(
-				int cachesize,
+			final int cachesize,
-				int maxrows,
+			final int maxrows,
-				int rstype,
+			final int rstype,
-				int rsconcur
+			final int rsconcur
 		) throws SQLException {
 			this.cachesize = cachesize;
 			this.maxrows = maxrows;
 			this.rstype = rstype;
 			this.rsconcur = rsconcur;
 		 */
 		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);
+					final Response tmp = responses.get(curResponse);
 					if (tmp != null)
 						tmp.close();
 					responses.set(curResponse, null);
 				}
 			}
 		/**
 		 * Closes the Response at index i, if not null.
 		 *
 		 * @param i the index position of the header to close
 		 */
-		void closeResponse(int i) {
+		void closeResponse(final int i) {
 			if (i < 0 || i >= responses.size())
 				return;
-			Response tmp = responses.set(i, null);
+			final Response tmp = responses.set(i, null);
 			if (tmp != null)
 				tmp.close();
 		}
 		/**
 		 * stores the Responses resulting from this query in this
 		 * ResponseList.
 		 *
 		 * @throws SQLException if a database error occurs
 		 */
-		void processQuery(String query) throws SQLException {
+		void processQuery(final String query) throws SQLException {
 			executeQuery(queryTempl, query);
 		}
 		/**
 		 * Internal executor of queries.
 		 * @param templ the template to fill in
 		 * @param the query to execute
 		 * @throws SQLException if a database error occurs
 		 */
 		@SuppressWarnings("fallthrough")
-		void executeQuery(String[] templ, String query)
+		void executeQuery(final String[] templ, final String query)
 			throws SQLException
 		{
 			String error = null;
 			try {
 								switch (sohp.parse(tmpLine)) {
 								case StartOfHeaderParser.Q_PARSE:
 									throw new MCLParseException("Q_PARSE header not allowed here", 1);
 								case StartOfHeaderParser.Q_TABLE:
 								case StartOfHeaderParser.Q_PREPARE: {
-									int id = sohp.getNextAsInt();
+									final int id = sohp.getNextAsInt();
 									int tuplecount = sohp.getNextAsInt();
-									int columncount = sohp.getNextAsInt();
+									final int columncount = sohp.getNextAsInt();
-									int rowcount = sohp.getNextAsInt();
+									final int rowcount = sohp.getNextAsInt();
 									// enforce the maxrows setting
 									if (maxrows != 0 && tuplecount > maxrows)
 										tuplecount = maxrows;
 									res = new ResultSetResponse(id, tuplecount, columncount, rowcount, this, seqnr);
 									// only add this resultset to the hashmap if it can possibly have an additional datablock
 									break;
 								case StartOfHeaderParser.Q_SCHEMA:
 									res = new SchemaResponse();
 									break;
 								case StartOfHeaderParser.Q_TRANS:
-									boolean ac = sohp.getNextAsString().equals("t") ? true : false;
+									final boolean ac = sohp.getNextAsString().equals("t") ? true : false;
 									if (autoCommit && ac) {
 										addWarning("Server enabled auto commit mode " +
 											"while local state already was auto commit.", "01M11");
 									}
 									autoCommit = ac;
 									res = new AutoCommitResponse(ac);
 									break;
 								case StartOfHeaderParser.Q_BLOCK: {
 									// a new block of results for a response...
-									int id = sohp.getNextAsInt();
+									final int id = sohp.getNextAsInt();
 									sohp.getNextAsInt();	// columncount
-									int rowcount = sohp.getNextAsInt();
+									final int rowcount = sohp.getNextAsInt();
-									int offset = sohp.getNextAsInt();
+									final int offset = sohp.getNextAsInt();
-									ResultSetResponse t = rsresponses.get(Integer.valueOf(id));
+									final ResultSetResponse t = (rsresponses != null) ? rsresponses.get(Integer.valueOf(id)) : null;
 									if (t == null) {
 										error = "M0M12!no ResultSetResponse with id " + id + " found";
 										break;
 									}
-									DataBlockResponse r = new DataBlockResponse(rowcount, t.getRSType() == ResultSet.TYPE_FORWARD_ONLY);
+									final DataBlockResponse r = new DataBlockResponse(rowcount, t.getRSType() == ResultSet.TYPE_FORWARD_ONLY);
 									t.addDataBlockResponse(offset, r);
 									res = r;
 								} break;
 								} // end of switch (sohp.parse(tmpLine))
 							} catch (MCLParseException e) {
 					} // end of while (linetype != BufferedMCLReader.PROMPT)
 				} // end of synchronized (server)
 				if (error != null) {
 					SQLException ret = null;
-					String[] errors = error.split("\n");
+					final String[] errors = error.split("\n");
 					for (int i = 0; i < errors.length; i++) {
-						SQLException newErr;
+						final SQLException newErr;
 						if (errors[i].length() >= 6) {
 							newErr = new SQLException(errors[i].substring(6), errors[i].substring(0, 5));
 						} else {
 							newErr = new SQLNonTransientConnectionException(errors[i], "08000");
 						}

Mercurial > hg > monetdb-java

comparison src/main/java/nl/cwi/monetdb/jdbc/MonetConnection.java @ 295:003ae6d881db