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

comparison src/main/java/nl/cwi/monetdb/jdbc/MonetConnection.java @ 172:60063c67f9e7 embedded

Merged with default

author	Pedro Ferreira <pedro.ferreira@monetdbsolutions.com>
date	Tue, 19 Sep 2017 13:49:34 +0200 (2017-09-19)
parents	6c74540a8e6b 89e954e7acbb
children	89c285fc0a49

comparison

equal deleted inserted replaced

-:0f95fee3cf29
+:60063c67f9e7
 import nl.cwi.monetdb.mcl.protocol.ServerResponses;
 import nl.cwi.monetdb.mcl.protocol.StarterHeaders;
 import nl.cwi.monetdb.mcl.responses.*;
 import java.io.IOException;
+import java.net.SocketException;
 import java.net.SocketTimeoutException;
 import java.sql.*;
 import java.util.*;
 import java.util.concurrent.Executor;
 * whole Connection interface.
 *
 * @author Fabian Groffen, Martin van Dinther, Pedro Ferreira
 * @version 1.3
 */
-public abstract class MonetConnection extends MonetWrapper implements Connection {
+public abstract class MonetConnection extends MonetWrapper implements Connection, AutoCloseable {
-/** The sequence counter */
+	/** The sequence counter */
-private static int SeqCounter = 0;
+	private static int SeqCounter = 0;
-/**
+	/**
-* Gets the current sequence counter.
+	 * Gets the current sequence counter.
-*
+	 *
-* @return The current sequence counter
+	 * @return The current sequence counter
-*/
+	 */
-public static int getSeqCounter() {
+	public static int getSeqCounter() {
-return SeqCounter;
+		return SeqCounter;
-}
+	}
-/** The successful processed input properties */
+	/** The successful processed input properties */
-protected final Properties conn_props;
+	protected final Properties conn_props;
-/** The language to connect with */
+	/** The language to connect with */
-protected IMonetDBLanguage language;
+	protected IMonetDBLanguage language;
-/** Authentication hash method */
+	/** Authentication hash method */
-protected final String hash;
+	protected final String hash;
-/** An optional thread that is used for sending large queries */
+	/** An optional thread that is used for sending large queries */
-private SenderThread senderThread;
+	private SenderThread senderThread;
-/** Whether this Connection is closed (and cannot be used anymore) */
+	/** Whether this Connection is closed (and cannot be used anymore) */
-private boolean closed;
+	private boolean closed;
-/** Whether this Connection is in autocommit mode */
+	/** Whether this Connection is in autocommit mode */
-private boolean autoCommit = true;
+	private boolean autoCommit = true;
-/** The stack of warnings for this Connection object */
+	/** The stack of warnings for this Connection object */
-private SQLWarning warnings;
+	private SQLWarning warnings;
-/** The Connection specific mapping of user defined types to Java types */
+	/** The Connection specific mapping of user defined types to Java types */
-private Map<String,Class<?>> typeMap = new HashMap<String,Class<?>>() {
+	private Map<String,Class<?>> typeMap = new HashMap<String,Class<?>>() {
-private static final long serialVersionUID = 1L; {
+		private static final long serialVersionUID = 1L; {
-put("inet", MonetINET.class);
+			put("inet", MonetINET.class);
-put("url", MonetURL.class);
+			put("url", MonetURL.class);
-}
+		}
-};
+	};
-// See javadoc for documentation about WeakHashMap if you don't know what it does !!!NOW!!!
+	// See javadoc for documentation about WeakHashMap if you don't know what it does !!!NOW!!!
-// (only when you deal with it of course)
+	// (only when you deal with it of course)
-/** A Map containing all (active) Statements created from this Connection */
+	/** A Map containing all (active) Statements created from this Connection */
-private Map<Statement,?> statements = new WeakHashMap<>();
+	private Map<Statement,?> statements = new WeakHashMap<>();
-/** The number of results we receive from the server at once */
+	/** The number of results we receive from the server at once */
-private int curReplySize = -1; // the server by default uses -1 (all)
+	private int curReplySize = -1; // the server by default uses -1 (all)
-/** Whether or not BLOB is mapped to LONGVARBINARY within the driver */
+	/** Whether or not BLOB is mapped to LONGVARBINARY within the driver */
-private final boolean blobIsBinary;
+	private final boolean blobIsBinary;
-/** Whether or not CLOB is mapped to LONGVARCHAR within the driver */
+	/** Whether or not CLOB is mapped to LONGVARCHAR within the driver */
-private final boolean clobIsLongChar;
+	private final boolean clobIsLongChar;
-/** The underlying proticol provided by the connection (MAPI or embedded) */
+	/** The underlying proticol provided by the connection (MAPI or embedded) */
-protected AbstractProtocol protocol;
+	protected AbstractProtocol protocol;
-/** Tells if the connection is embedded or not */
+	/** Tells if the connection is embedded or not */
-private final boolean isEmbedded;
+	private final boolean isEmbedded;
-/**
+	/**
-* Constructor of a Connection for MonetDB. At this moment the current implementation limits itself to storing the
+	 * Constructor of a Connection for MonetDB. At this moment the current implementation limits itself to storing the
-* given host, database, username and password for later use by the createStatement() call.  This constructor is
+	 * given host, database, username and password for later use by the createStatement() call.  This constructor is
-* only accessible to classes from the jdbc package.
+	 * only accessible to classes from the jdbc package.
-*
+	 */
-* @throws IOException if an error occurs
+	public MonetConnection(Properties props, String hash, IMonetDBLanguage language, boolean blobIsBinary,
-*/
+						   boolean clobIsLongChar) {
-public MonetConnection(Properties props, String hash, IMonetDBLanguage language, boolean blobIsBinary,
+		this.conn_props = props;
-boolean clobIsLongChar) throws IOException {
+		this.hash = hash;
-this.conn_props = props;
+		this.language = language;
-this.hash = hash;
+		this.blobIsBinary = blobIsBinary;
-this.language = language;
+		this.clobIsLongChar = clobIsLongChar;
-this.blobIsBinary = blobIsBinary;
+		//"instance of" should be cleanner, but this is faster.
-this.clobIsLongChar = clobIsLongChar;
+		this.isEmbedded = props.getProperty("embedded", "false").equals("true");
-//"instance of" should be cleanner, but this is faster.
+	}
-this.isEmbedded = props.getProperty("embedded", "false").equals("true");
-}
+	/**
+	 * Checks if the conection is embedded or not
-/**
+	 *
-* Checks if the conection is embedded or not
+	 * @return If the connection is embedded
-*
+	 */
-* @return If the connection is embedded
+	public boolean isEmbedded() {
-*/
+		return isEmbedded;
-public boolean isEmbedded() {
+	}
-return isEmbedded;
-}
+	/**
+	 * Gets the connection's language data.
-/**
+	 *
-* Gets the connection's language data.
+	 * @return The connection's language data
-*
+	 */
-* @return The connection's language data
+	public IMonetDBLanguage getLanguage() {
-*/
+		return language;
-public IMonetDBLanguage getLanguage() {
+	}
-return language;
-}
+	/**
+	 * Gets the connection's protocol.
-/**
+	 *
-* Gets the connection's protocol.
+	 * @return The connection's protocol
-*
+	 */
-* @return The connection's protocol
+	public AbstractProtocol getProtocol() {
-*/
+		return this.protocol;
-public AbstractProtocol getProtocol() {
+	}
-return this.protocol;
-}
+	/**
+	 * Connects to the server, authenticating the user.
-/**
+	 *
-* Connects to the server, authenticating the user.
+	 * @param user The user name to authenticate
-*
+	 * @param pass The user's password
-* @param user The user name to authenticate
+	 * @return A List with informational (warning) messages. If this list is empty; then there are no warnings.
-* @param pass The user's password
+	 * @throws IOException if an I/O error occurs when creating the socket
-* @return A List with informational (warning) messages. If this list is empty; then there are no warnings.
+	 * @throws ProtocolException if bogus data is received
-* @throws IOException if an I/O error occurs when creating the socket
+	 * @throws MCLException if an MCL related error occurs
-* @throws ProtocolException if bogus data is received
+	 */
-* @throws MCLException if an MCL related error occurs
+	public abstract List<String> connect(String user, String pass) throws IOException, ProtocolException, MCLException;
-*/
-public abstract List<String> connect(String user, String pass) throws IOException, ProtocolException, MCLException;
+	/**
+	 * Gets the underlying connection block size length.
-/**
+	 *
-* Gets the underlying connection block size length.
+	 * @return The block size length
-*
+	 */
-* @return The block size length
+	public abstract int getBlockSize();
-*/
-public abstract int getBlockSize();
+	/**
+	 * Gets the underlying connection default fetch size for DataBlock responses.
-/**
+	 *
-* Gets the underlying connection default fetch size for DataBlock responses.
+	 * @return The default fetch size
-*
+	 */
-* @return The default fetch size
+	public abstract int getDefFetchsize();
-*/
-public abstract int getDefFetchsize();
+	/**
+	 * Gets the initial value for the StringBuilder size.
-/**
+	 *
-* Gets the initial value for the StringBuilder size.
+	 * @return The initial value for the StringBuilder size
-*
+	 */
-* @return The initial value for the StringBuilder size
+	public abstract int initialStringBuilderSize();
-*/
-public abstract int initialStringBuilderSize();
+	/**
+	 * Gets the underlying connection socket timeout.
-/**
+	 *
-* Gets the underlying connection socket timeout.
+	 * @return The underlying connection socket timeout
-*
+	 */
-* @return The underlying connection socket timeout
+	public abstract int getSoTimeout() throws SocketException;
-*/
-public abstract int getSoTimeout();
+	/**
+	 * Sets the underlying connection socket timeout.
-/**
+	 *
-* Sets the underlying connection socket timeout.
+	 * @param timeout The specified timeout, in milliseconds. A timeout of zero is interpreted as an infinite timeout
-*
+	 */
-* @param timeout The specified timeout, in milliseconds. A timeout of zero is interpreted as an infinite timeout
+	public abstract void setSoTimeout(int timeout) throws SocketException;
-*/
-public abstract void setSoTimeout(int timeout);
+	/**
+	 * Closes the underlying connection implementation.
-/**
+	 *
-* Closes the underlying connection implementation.
+	 * @throws IOException if an I/O error occurs while closing the connection
-*
+	 */
-* @throws IOException if an I/O error occurs while closing the connection
+	public abstract void closeUnderlyingConnection() throws IOException;
-*/
-public abstract void closeUnderlyingConnection() throws IOException;
+	/**
+	 * Gets the underlying connection JDBC String URL.
-/**
+	 *
-* Gets the underlying connection JDBC String URL.
+	 * @return The underlying connection JDBC String URL
-*
+	 */
-* @return The underlying connection JDBC String URL
+	public abstract String getJDBCURL();
-*/
-public abstract String getJDBCURL();
+	/**
+	 * Sends a control command to the server.
-/**
+	 *
-* Sends a control command to the server.
+	 * @param commandID the command identifier according to {@link ControlCommands} listing
-*
+	 * @param data The integer to send according to the control command
-* @param commandID the command identifier according to {@link ControlCommands} listing
+	 * @throws SQLException if an IO exception or a database error occurs
-* @param data The integer to send according to the control command
+	 */
-* @throws SQLException if an IO exception or a database error occurs
+	public abstract void sendControlCommand(int commandID, int data) throws SQLException;
-*/
-public abstract void sendControlCommand(int commandID, int data) throws SQLException;
+	/**
+	 * Releases this Connection object's database and JDBC resources immediately instead of waiting for them to be
-/**
+	 * automatically released. All Statements created from this Connection will be closed when this method is called.
-* Releases this Connection object's database and JDBC resources immediately instead of waiting for them to be
+	 *
-* automatically released. All Statements created from this Connection will be closed when this method is called.
+	 * Calling the method close on a Connection object that is already closed is a no-op.
-*
+	 */
-* Calling the method close on a Connection object that is already closed is a no-op.
+	@Override
-*/
+	public void close() {
-@Override
+		for (Statement st : statements.keySet()) {
-public void close() {
+			try {
-for (Statement st : statements.keySet()) {
+				st.close();
-try {
+			} catch (SQLException e) {
-st.close();
+				// better luck next time!
-} catch (SQLException e) {
+			}
-// better luck next time!
+		}
-}
+		// close the socket or the embedded server
-}
+		try {
-// close the socket or the embedded server
+			this.closeUnderlyingConnection();
-try {
+		} catch (IOException e) {
-this.closeUnderlyingConnection();
+			// ignore it
-} catch (IOException e) {
+		}
-// ignore it
+		// close active SendThread if any
-}
+		if (senderThread != null) {
-// close active SendThread if any
+			senderThread.shutdown();
-if (senderThread != null) {
+			senderThread = null;
-senderThread.shutdown();
+		}
-senderThread = null;
+		// report ourselves as closed
-}
+		closed = true;
-// report ourselves as closed
+	}
-closed = true;
-}
+	/**
+	 * Destructor called by garbage collector before destroying this object tries to disconnect the MonetDB connection
-/**
+	 * if it has not been disconnected already.
-* Destructor called by garbage collector before destroying this object tries to disconnect the MonetDB connection
+	 */
-* if it has not been disconnected already.
+	@Override
-*/
+	protected void finalize() throws Throwable {
-@Override
+		this.close();
-protected void finalize() throws Throwable {
+		super.finalize();
-this.close();
+	}
-super.finalize();
-}
+	//== methods of interface Connection
-//== methods of interface Connection
+	/**
+	 * Clears all warnings reported for this Connection object. After a call to this method, the method getWarnings
-/**
+	 * returns null until a new warning is reported for this Connection object.
-* Clears all warnings reported for this Connection object. After a call to this method, the method getWarnings
+	 */
-* returns null until a new warning is reported for this Connection object.
+	@Override
-*/
+	public void clearWarnings() {
-@Override
+		warnings = null;
-public void clearWarnings() {
+	}
-warnings = null;
-}
+	/**
+	 * Makes all changes made since the previous commit/rollback permanent and releases any database locks currently
-private void createResponseList(String query) throws SQLException {
+	 * held by this Connection object. This method should be used only when auto-commit mode has been disabled.
-// create a container for the result
+	 *
-ResponseList l = new ResponseList(0, 0, ResultSet.FETCH_FORWARD, ResultSet.CONCUR_READ_ONLY);
+	 * @throws SQLException if a database access error occurs or this Connection object is in auto-commit mode
-// send commit to the server
+	 * @see #setAutoCommit(boolean)
-try {
+	 */
-l.processQuery(query);
+	@Override
-} finally {
+	public void commit() throws SQLException {
-l.close();
+		// note: can't use sendIndependentCommand here because we need to process the auto_commit state the server gives
-}
+		this.sendTransactionCommand("COMMIT");
-}
+	}
-/**
+	/**
-* Makes all changes made since the previous commit/rollback permanent and releases any database locks currently
+	 * Creates a Statement object for sending SQL statements to the
-* held by this Connection object. This method should be used only when auto-commit mode has been disabled.
+	 * database.  SQL statements without parameters are normally
-*
+	 * executed using Statement objects. If the same SQL statement is
-* @throws SQLException if a database access error occurs or this Connection object is in auto-commit mode
+	 * executed many times, it may be more efficient to use a
-* @see #setAutoCommit(boolean)
+	 * PreparedStatement object.
-*/
+	 *
-@Override
+	 * Result sets created using the returned Statement object will by
-public void commit() throws SQLException {
+	 * default be type TYPE_FORWARD_ONLY and have a concurrency level of
-// note: can't use sendIndependentCommand here because we need to process the auto_commit state the server gives
+	 * CONCUR_READ_ONLY.
-this.createResponseList("COMMIT");
+	 *
-}
+	 * @return a new default Statement object
+	 * @throws SQLException if a database access error occurs
-/**
+	 */
-* Creates a Statement object for sending SQL statements to the database. SQL statements without parameters are
+	@Override
-* normally executed using Statement objects. If the same SQL statement is executed many times, it may be more
+	public Statement createStatement() throws SQLException {
-* efficient to use a PreparedStatement object.
+		return createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
-*
+	}
-* Result sets created using the returned Statement object will by default be type TYPE_FORWARD_ONLY and have a
-* concurrency level of CONCUR_READ_ONLY.
+	/**
-*
+	 * Creates a Statement object that will generate ResultSet objects
-* @return a new default Statement object
+	 * with the given type and concurrency. This method is the same as
-* @throws SQLException if a database access error occurs
+	 * the createStatement method above, but it allows the default
-*/
+	 * result set type and concurrency to be overridden.
-@Override
+	 *
-public Statement createStatement() throws SQLException {
+	 * @param resultSetType a result set type; one of
-return createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
+	 *        ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE,
-ResultSet.HOLD_CURSORS_OVER_COMMIT);
+	 *        or ResultSet.TYPE_SCROLL_SENSITIVE
-}
+	 * @param resultSetConcurrency a concurrency type; one of
+	 *        ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
-/**
+	 * @return a new Statement object that will generate ResultSet objects with
-* Creates a Statement object that will generate ResultSet objects with the given type and concurrency. This method
+	 *         the given type and concurrency
-* is the same as the createStatement method above, but it allows the default result set type and concurrency to be
+	 * @throws SQLException if a database access error occurs
-* overridden.
+	 */
-*
+	@Override
-* @param resultSetType a result set type; one of ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE,
+	public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
-* or ResultSet.TYPE_SCROLL_SENSITIVE
+		return createStatement(resultSetType, resultSetConcurrency, ResultSet.HOLD_CURSORS_OVER_COMMIT);
-* @param resultSetConcurrency a concurrency type; one of ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
+	}
-* @return a new Statement object that will generate ResultSet objects with the given type and concurrency
-* @throws SQLException if a database access error occurs
+	/**
-*/
+	 * Creates a Statement object that will generate ResultSet objects
-@Override
+	 * with the given type, concurrency, and holdability.  This method
-public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
+	 * is the same as the createStatement method above, but it allows
-return createStatement(resultSetType, resultSetConcurrency, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+	 * the default result set type, concurrency, and holdability to be
-}
+	 * overridden.
+	 *
-/**
+	 * @param resultSetType one of the following ResultSet constants:
-* Creates a Statement object that will generate ResultSet objects
+	 * ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE,
-* with the given type, concurrency, and holdability.  This method
+	 * or ResultSet.TYPE_SCROLL_SENSITIVE
-* is the same as the createStatement method above, but it allows
+	 * @param resultSetConcurrency one of the following ResultSet
-* the default result set type, concurrency, and holdability to be
+	 * constants: ResultSet.CONCUR_READ_ONLY or
-* overridden.
+	 * ResultSet.CONCUR_UPDATABLE
-*
+	 * @param resultSetHoldability one of the following ResultSet
-* @param resultSetType one of the following ResultSet constants:
+	 * constants: ResultSet.HOLD_CURSORS_OVER_COMMIT or
-* ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE,
+	 * ResultSet.CLOSE_CURSORS_AT_COMMIT
-* or ResultSet.TYPE_SCROLL_SENSITIVE
+	 *
-* @param resultSetConcurrency one of the following ResultSet
+	 * @return a new Statement      object that will generate ResultSet
-* constants: ResultSet.CONCUR_READ_ONLY or
+	 * objects with the given type, concurrency, and holdability
-* ResultSet.CONCUR_UPDATABLE
+	 * @throws SQLException if a database access error occurs or the
-* @param resultSetHoldability one of the following ResultSet
+	 * given parameters are not ResultSet constants indicating type,
-* constants: ResultSet.HOLD_CURSORS_OVER_COMMIT or
+	 * concurrency, and holdability
-* ResultSet.CLOSE_CURSORS_AT_COMMIT
+	 */
-*
+	@Override
-* @return a new Statement      object that will generate ResultSet
+	public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
-* objects with the given type, concurrency, and holdability
+		try {
-* @throws SQLException if a database access error occurs or the
+			Statement ret = new MonetStatement(this, resultSetType, resultSetConcurrency, resultSetHoldability);
-* given parameters are not ResultSet constants indicating type,
+			// store it in the map for when we close...
-* concurrency, and holdability
+			statements.put(ret, null);
-*/
+			return ret;
-@Override
+		} catch (IllegalArgumentException e) {
-public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
+			throw new SQLException(e.toString(), "M0M03");
-throws SQLException {
+		}
-try {
+		// we don't have to catch SQLException because that is declared to
-Statement ret = new MonetStatement(this, resultSetType, resultSetConcurrency, resultSetHoldability);
+		// be thrown
-// store it in the map for when we close...
+	}
-statements.put(ret, null);
-return ret;
+	/**
-} catch (IllegalArgumentException e) {
+	 * Retrieves the current auto-commit mode for this Connection object.
-throw new SQLException(e.toString(), "M0M03");
+	 *
-}
+	 * @return the current state of this Connection object's auto-commit mode
-// we don't have to catch SQLException because that is declared to
+	 * @see #setAutoCommit(boolean)
-// be thrown
+	 */
-}
+	@Override
+	public boolean getAutoCommit() throws SQLException {
-/**
+		return autoCommit;
-* Retrieves the current auto-commit mode for this Connection object.
+	}
-*
-* @return the current state of this Connection object's auto-commit mode
+	/**
-* @see #setAutoCommit(boolean)
+	 * Retrieves this Connection object's current catalog name.
-*/
+	 *
-@Override
+	 * @return the current catalog name or null if there is none
-public boolean getAutoCommit() throws SQLException {
+	 * @throws SQLException if a database access error occurs or the current language is not SQL
-return autoCommit;
+	 */
-}
+	@Override
+	public String getCatalog() throws SQLException {
-/**
+		// MonetDB does NOT support catalogs
-* Retrieves this Connection object's current catalog name.
+		return null;
-*
+	}
-* @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
+	/**
-*/
+	 * Retrieves the current holdability of ResultSet objects created using this Connection object.
-@Override
+	 *
-public String getCatalog() throws SQLException {
+	 * @return the holdability, one of ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
-// MonetDB does NOT support catalogs
+	 */
-return null;
+	@Override
-}
+	public int getHoldability() {
+		// TODO: perhaps it is better to have the server implement
-/**
+		//       CLOSE_CURSORS_AT_COMMIT
-* Retrieves the current holdability of ResultSet objects created using this Connection object.
+		return ResultSet.HOLD_CURSORS_OVER_COMMIT;
-*
+	}
-* @return the holdability, one of ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
-*/
+	/**
-@Override
+	 * Retrieves a DatabaseMetaData object that contains metadata about
-public int getHoldability() {
+	 * the database to which this Connection object represents a
-// TODO: perhaps it is better to have the server implement
+	 * connection. The metadata includes information about the
-//       CLOSE_CURSORS_AT_COMMIT
+	 * database's tables, its supported SQL grammar, its stored
-return ResultSet.HOLD_CURSORS_OVER_COMMIT;
+	 * procedures, the capabilities of this connection, and so on.
-}
+	 *
+	 * @throws SQLException if the current language is not SQL
-/**
+	 * @return a DatabaseMetaData object for this Connection object
-* Retrieves a DatabaseMetaData object that contains metadata about
+	 */
-* the database to which this Connection object represents a
+	@Override
-* connection. The metadata includes information about the
+	public DatabaseMetaData getMetaData() throws SQLException {
-* database's tables, its supported SQL grammar, its stored
+		if (!this.language.getRepresentation().equals("sql")) {
-* procedures, the capabilities of this connection, and so on.
+			throw new SQLException("This method is only supported in SQL mode", "M0M04");
-*
+		}
-* @throws SQLException if the current language is not SQL
+		return new MonetDatabaseMetaData(this);
-* @return a DatabaseMetaData object for this Connection object
+	}
-*/
-@Override
+	/**
-public DatabaseMetaData getMetaData() throws SQLException {
+	 * Retrieves this Connection object's current transaction isolation level.
-if (!this.language.getRepresentation().equals("sql")) {
+	 *
-throw new SQLException("This method is only supported in SQL mode", "M0M04");
+	 * @return the current transaction isolation level, which will be Connection.TRANSACTION_SERIALIZABLE
-}
+	 */
-return new MonetDatabaseMetaData(this);
+	@Override
-}
+	public int getTransactionIsolation() {
+		return TRANSACTION_SERIALIZABLE;
-/**
+	}
-* Retrieves this Connection object's current transaction isolation level.
-*
+	/**
-* @return the current transaction isolation level, which will be Connection.TRANSACTION_SERIALIZABLE
+	 * Retrieves the Map object associated with this Connection object. Unless the application has added an entry,
-*/
+	 * the type map returned will be empty.
-@Override
+	 *
-public int getTransactionIsolation() {
+	 * @return the java.util.Map object associated with this Connection object
-return TRANSACTION_SERIALIZABLE;
+	 */
-}
+	@Override
+	public Map<String,Class<?>> getTypeMap() {
-/**
+		return typeMap;
-* Retrieves the Map object associated with this Connection object. Unless the application has added an entry,
+	}
-* the type map returned will be empty.
-*
+	/**
-* @return the java.util.Map object associated with this Connection object
+	 * Retrieves the first warning reported by calls on this Connection
-*/
+	 * object.  If there is more than one warning, subsequent warnings
-@Override
+	 * will be chained to the first one and can be retrieved by calling
-public Map<String,Class<?>> getTypeMap() {
+	 * the method SQLWarning.getNextWarning on the warning that was
-return typeMap;
+	 * retrieved previously.
-}
+	 *
+	 * This method may not be called on a closed connection; doing so will cause an SQLException to be thrown.
-/**
+	 *
-* Retrieves the first warning reported by calls on this Connection
+	 * Note: Subsequent warnings will be chained to this SQLWarning.
-* object.  If there is more than one warning, subsequent warnings
+	 *
-* will be chained to the first one and can be retrieved by calling
+	 * @return the first SQLWarning object or null if there are none
-* the method SQLWarning.getNextWarning on the warning that was
+	 * @throws SQLException if a database access error occurs or this method is called on a closed connection
-* retrieved previously.
+	 */
-*
+	@Override
-* This method may not be called on a closed connection; doing so will cause an SQLException to be thrown.
+	public SQLWarning getWarnings() throws SQLException {
-*
+		if (closed) {
-* Note: Subsequent warnings will be chained to this SQLWarning.
+			throw new SQLException("Cannot call on closed Connection", "M1M20");
-*
+		}
-* @return the first SQLWarning object or null if there are none
+		// if there are no warnings, this will be null, which fits with the specification.
-* @throws SQLException if a database access error occurs or this method is called on a closed connection
+		return warnings;
-*/
+	}
-@Override
-public SQLWarning getWarnings() throws SQLException {
+	/**
-if (closed) {
+	 * Retrieves whether this Connection object has been closed.  A
-throw new SQLException("Cannot call on closed Connection", "M1M20");
+	 * connection is closed if the method close has been called on it or
-}
+	 * if certain fatal errors have occurred.  This method is guaranteed
-// if there are no warnings, this will be null, which fits with the specification.
+	 * to return true only when it is called after the method
-return warnings;
+	 * Connection.close has been called.
-}
+	 *
+	 * This method generally cannot be called to determine whether a
-/**
+	 * connection to a database is valid or invalid.  A typical client
-* Retrieves whether this Connection object has been closed.  A
+	 * can determine that a connection is invalid by catching any
-* connection is closed if the method close has been called on it or
+	 * exceptions that might be thrown when an operation is attempted.
-* if certain fatal errors have occurred.  This method is guaranteed
+	 *
-* to return true only when it is called after the method
+	 * @return true if this Connection object is closed; false if it is still open
-* Connection.close has been called.
+	 */
-*
+	@Override
-* This method generally cannot be called to determine whether a
+	public boolean isClosed() {
-* connection to a database is valid or invalid.  A typical client
+		return closed;
-* can determine that a connection is invalid by catching any
+	}
-* exceptions that might be thrown when an operation is attempted.
-*
+	/**
-* @return true if this Connection object is closed; false if it is still open
+	 * Retrieves whether this Connection object is in read-only mode.
-*/
+	 * MonetDB currently doesn't support updateable result sets, but
-@Override
+	 * updates are possible.  Hence the Connection object is never in
-public boolean isClosed() {
+	 * read-only mode.
-return closed;
+	 *
-}
+	 * @return true if this Connection object is read-only; false otherwise
+	 */
-/**
+	@Override
-* Retrieves whether this Connection object is in read-only mode.
+	public boolean isReadOnly() {
-* MonetDB currently doesn't support updateable result sets, but
+		return false;
-* updates are possible.  Hence the Connection object is never in
+	}
-* read-only mode.
-*
+	@Override
-* @return true if this Connection object is read-only; false otherwise
+	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 boolean isReadOnly() {
+		return sql;
-return false;
+	}
-}
+	@Override
-@Override
+	public CallableStatement prepareCall(String sql) {
-public String nativeSQL(String sql) {return sql;}
+		/* not implemented yet */
+		return null;
-@Override
+	}
-public CallableStatement prepareCall(String sql) {return null;}
+	@Override
-@Override
+	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) {
-public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) {return null;}
+		/* not implemented yet */
+		return null;
-@Override
+	}
-public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
-int resultSetHoldability) {return null;}
+	@Override
+	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) {
-/**
+		/* not implemented yet */
-* Creates a PreparedStatement object for sending parameterized SQL
+		return null;
-* statements to the database.
+	}
-*
-* A SQL statement with or without IN parameters can be pre-compiled
+	/**
-* and stored in a PreparedStatement object. This object can then be
+	 * Creates a PreparedStatement object for sending parameterized SQL
-* used to efficiently execute this statement multiple times.
+	 * statements to the database.
-*
+	 *
-* Note: This method is optimized for handling parametric SQL
+	 * A SQL statement with or without IN parameters can be pre-compiled
-* statements that benefit from precompilation. If the driver
+	 * and stored in a PreparedStatement object. This object can then be
-* supports precompilation, the method prepareStatement will send
+	 * used to efficiently execute this statement multiple times.
-* the statement to the database for precompilation. Some drivers
+	 *
-* may not support precompilation. In this case, the statement may
+	 * Note: This method is optimized for handling parametric SQL
-* not be sent to the database until the PreparedStatement object is
+	 * statements that benefit from precompilation. If the driver
-* executed. This has no direct effect on users; however, it does
+	 * supports precompilation, the method prepareStatement will send
-* affect which methods throw certain SQLException objects.
+	 * the statement to the database for precompilation. Some drivers
-*
+	 * may not support precompilation. In this case, the statement may
-* Result sets created using the returned PreparedStatement object
+	 * not be sent to the database until the PreparedStatement object is
-* will by default be type TYPE_FORWARD_ONLY and have a concurrency
+	 * executed. This has no direct effect on users; however, it does
-* level of CONCUR_READ_ONLY.
+	 * affect which methods throw certain SQLException objects.
-*
+	 *
-* @param sql an SQL statement that may contain one or more '?' IN
+	 * Result sets created using the returned PreparedStatement object
-*        parameter placeholders
+	 * will by default be type TYPE_FORWARD_ONLY and have a concurrency
-* @return a new default PreparedStatement object containing the
+	 * level of CONCUR_READ_ONLY.
-*         pre-compiled SQL statement
+	 *
-* @throws SQLException if a database access error occurs
+	 * @param sql an SQL statement that may contain one or more '?' IN
-*/
+	 *        parameter placeholders
-@Override
+	 * @return a new default PreparedStatement object containing the
-public PreparedStatement prepareStatement(String sql) throws SQLException {
+	 *         pre-compiled SQL statement
-return prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
+	 * @throws SQLException if a database access error occurs
-ResultSet.HOLD_CURSORS_OVER_COMMIT);
+	 */
-}
+	@Override
+	public PreparedStatement prepareStatement(String sql) throws SQLException {
-/**
+		return prepareStatement(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
-* same as the prepareStatement method above, but it allows the
+	/**
-* default result set type and concurrency to be overridden.
+	 * Creates a PreparedStatement object that will generate ResultSet
-*
+	 * objects with the given type and concurrency.  This method is the
-* @param sql a String object that is the SQL statement to be sent to the
+	 * same as the prepareStatement method above, but it allows the
-*            database; may contain one or more ? IN parameters
+	 * default result set type and concurrency to be overridden.
-* @param resultSetType a result set type; one of
+	 *
-*        ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE,
+	 * @param sql a String object that is the SQL statement to be sent to the
-*        or ResultSet.TYPE_SCROLL_SENSITIVE
+	 *        database; may contain one or more ? IN parameters
-* @param resultSetConcurrency a concurrency type; one of
+	 * @param resultSetType a result set type; one of
-*        ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
+	 *        ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE,
-* @return a new PreparedStatement object containing the pre-compiled SQL
+	 *        or ResultSet.TYPE_SCROLL_SENSITIVE
-*         statement that will produce ResultSet objects with the given
+	 * @param resultSetConcurrency a concurrency type; one of
-*         type and concurrency
+	 *        ResultSet.CONCUR_READ_ONLY or ResultSet.CONCUR_UPDATABLE
-* @throws SQLException if a database access error occurs or the given
+	 * @return a new PreparedStatement object containing the pre-compiled SQL
-*                      parameters are not ResultSet constants indicating
+	 *         statement that will produce ResultSet objects with the given
-*                      type and concurrency
+	 *         type and concurrency
-*/
+	 * @throws SQLException if a database access error occurs or the given
-@Override
+	 *         parameters are not ResultSet constants indicating
-public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
+	 *         type and concurrency
-throws SQLException {
+	 */
-return prepareStatement(sql, resultSetType, resultSetConcurrency, ResultSet.HOLD_CURSORS_OVER_COMMIT);
+	@Override
-}
+	public PreparedStatement prepareStatement(String sql, 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.
+	/**
-*
+	 * Creates a PreparedStatement object that will generate ResultSet
-* This method is the same as the prepareStatement method above, but
+	 * objects with the given type, concurrency, and holdability.
-* it allows the default result set type, concurrency, and
+	 *
-* holdability to be overridden.
+	 * This method is the same as the prepareStatement method above, but
-*
+	 * it allows the default result set type, concurrency, and
-* @param sql a String object that is the SQL statement to be sent
+	 * holdability to be overridden.
-* to the database; may contain one or more ? IN parameters
+	 *
-* @param resultSetType one of the following ResultSet constants:
+	 * @param sql a String object that is the SQL statement to be sent
-* ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE,
+	 * to the database; may contain one or more ? IN parameters
-* or ResultSet.TYPE_SCROLL_SENSITIVE
+	 * @param resultSetType one of the following ResultSet constants:
-* @param resultSetConcurrency one of the following ResultSet
+	 * ResultSet.TYPE_FORWARD_ONLY, ResultSet.TYPE_SCROLL_INSENSITIVE,
-* constants: ResultSet.CONCUR_READ_ONLY or
+	 * or ResultSet.TYPE_SCROLL_SENSITIVE
-* ResultSet.CONCUR_UPDATABLE
+	 * @param resultSetConcurrency one of the following ResultSet
-* @param resultSetHoldability one of the following ResultSet
+	 * constants: ResultSet.CONCUR_READ_ONLY or
-* constants: ResultSet.HOLD_CURSORS_OVER_COMMIT or
+	 * ResultSet.CONCUR_UPDATABLE
-* ResultSet.CLOSE_CURSORS_AT_COMMIT
+	 * @param resultSetHoldability one of the following ResultSet
-* @return a new PreparedStatement object, containing the
+	 * constants: ResultSet.HOLD_CURSORS_OVER_COMMIT or
-* pre-compiled SQL statement, that will generate ResultSet objects
+	 * ResultSet.CLOSE_CURSORS_AT_COMMIT
-* with the given type, concurrency, and holdability
+	 * @return a new PreparedStatement object, containing the
-* @throws SQLException if a database access error occurs or the
+	 * pre-compiled SQL statement, that will generate ResultSet objects
-* given parameters are not ResultSet constants indicating type,
+	 * with the given type, concurrency, and holdability
-* concurrency, and holdability
+	 * @throws SQLException if a database access error occurs or the
-*/
+	 * given parameters are not ResultSet constants indicating type,
-@Override
+	 * concurrency, and holdability
-public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
+	 */
-int resultSetHoldability) throws SQLException {
+	@Override
-try {
+	public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
-PreparedStatement ret = new MonetPreparedStatement(this, resultSetType, resultSetConcurrency,
+			throws SQLException {
-resultSetHoldability, sql);
+		try {
-// store it in the map for when we close...
+			PreparedStatement ret = new MonetPreparedStatement(this, resultSetType, resultSetConcurrency,
-statements.put(ret, null);
+					resultSetHoldability, sql);
-return ret;
+			// store it in the map for when we close...
-} catch (IllegalArgumentException e) {
+			statements.put(ret, null);
-throw new SQLException(e.toString(), "M0M03");
+			return ret;
-}
+		} catch (IllegalArgumentException e) {
-// we don't have to catch SQLException because that is declared to
+			throw new SQLException(e.toString(), "M0M03");
-// be thrown
+		}
-}
+		// we don't have to catch SQLException because that is declared to
+		// be thrown
-/**
+	}
-* Creates a default PreparedStatement object that has the
-* capability to retrieve auto-generated keys.  The given constant
+	/**
-* tells the driver whether it should make auto-generated keys
+	 * Creates a default PreparedStatement object that has the
-* available for retrieval.  This parameter is ignored if the SQL
+	 * capability to retrieve auto-generated keys.  The given constant
-* statement is not an INSERT statement.
+	 * tells the driver whether it should make auto-generated keys
-*
+	 * available for retrieval.  This parameter is ignored if the SQL
-* Note: This method is optimized for handling parametric SQL
+	 * statement is not an INSERT statement.
-* statements that benefit from precompilation.  If the driver
+	 *
-* supports precompilation, the method prepareStatement will send
+	 * Note: This method is optimized for handling parametric SQL
-* the statement to the database for precompilation. Some drivers
+	 * statements that benefit from precompilation.  If the driver
-* may not support precompilation.  In this case, the statement may
+	 * supports precompilation, the method prepareStatement will send
-* not be sent to the database until the PreparedStatement object is
+	 * the statement to the database for precompilation. Some drivers
-* executed.  This has no direct effect on users; however, it does
+	 * may not support precompilation.  In this case, the statement may
-* affect which methods throw certain SQLExceptions.
+	 * not be sent to the database until the PreparedStatement object is
-*
+	 * executed.  This has no direct effect on users; however, it does
-* Result sets created using the returned PreparedStatement object
+	 * affect which methods throw certain SQLExceptions.
-* will by default be type TYPE_FORWARD_ONLY and have a concurrency
+	 *
-* level of CONCUR_READ_ONLY.
+	 * Result sets created using the returned PreparedStatement object
-*
+	 * will by default be type TYPE_FORWARD_ONLY and have a concurrency
-* @param sql an SQL statement that may contain one or more '?' IN
+	 * level of CONCUR_READ_ONLY.
-*        parameter placeholders
+	 *
-* @param autoGeneratedKeys a flag indicating whether auto-generated
+	 * @param sql an SQL statement that may contain one or more '?' IN
-*        keys should be returned; one of
+	 *        parameter placeholders
-*        Statement.RETURN_GENERATED_KEYS or
+	 * @param autoGeneratedKeys a flag indicating whether auto-generated
-*        Statement.NO_GENERATED_KEYS
+	 *        keys should be returned; one of
-* @return a new PreparedStatement object, containing the
+	 *        Statement.RETURN_GENERATED_KEYS or
-*         pre-compiled SQL statement, that will have the capability
+	 *        Statement.NO_GENERATED_KEYS
-*         of returning auto-generated keys
+	 * @return a new PreparedStatement object, containing the
-* @throws SQLException - if a database access error occurs or the
+	 *         pre-compiled SQL statement, that will have the capability
-*         given parameter is not a Statement  constant indicating
+	 *         of returning auto-generated keys
-*         whether auto-generated keys should be returned
+	 * @throws SQLException - if a database access error occurs or the
-*/
+	 *         given parameter is not a Statement  constant indicating
-@Override
+	 *         whether auto-generated keys should be returned
-public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
+	 */
-if (autoGeneratedKeys != Statement.RETURN_GENERATED_KEYS && autoGeneratedKeys != Statement.NO_GENERATED_KEYS) {
+	@Override
-throw new SQLException("Invalid argument, expected RETURN_GENERATED_KEYS or NO_GENERATED_KEYS", "M1M05");
+	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
-}
+		if (autoGeneratedKeys != Statement.RETURN_GENERATED_KEYS &&
-		/* MonetDB has no way to disable this, so just do the normal thing ;) */
+				autoGeneratedKeys != Statement.NO_GENERATED_KEYS)
-return prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
+			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
-@Override
+		 * thing ;) */
-public PreparedStatement prepareStatement(String sql, int[] columnIndexes) {return null;}
+		return prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
+	}
-@Override
-public PreparedStatement prepareStatement(String sql, String[] columnNames) {return null;}
+	/**
+	 * 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.
-* Removes the given Savepoint object from the current transaction.
+	 * The driver will ignore the array if the SQL statement is not an INSERT statement, or an SQL statement able to
-* Any reference to the savepoint after it have been removed will
+	 * return auto-generated keys (the list of such statements is vendor-specific).
-* cause an SQLException to be thrown.
+	 *
-*
+	 * An SQL statement with or without IN parameters can be pre-compiled and stored in a PreparedStatement object.
-* @param savepoint the Savepoint object to be removed
+	 * This object can then be used to efficiently execute this statement multiple times.
-* @throws SQLException if a database access error occurs or the given
+	 *
-*         Savepoint object is not a valid savepoint in the current
+	 * Note: This method is optimized for handling parametric SQL statements that benefit from precompilation.
-*         transaction
+	 * 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
-@Override
+	 * object is executed. This has no direct effect on users; however, it does affect which methods throw certain SQLExceptions.
-public void releaseSavepoint(Savepoint savepoint) throws SQLException {
+	 *
-if (!(savepoint instanceof MonetSavepoint)) {
+	 * Result sets created using the returned PreparedStatement object will by default be type TYPE_FORWARD_ONLY and have
-throw new SQLException("This driver can only handle savepoints it created itself", "M0M06");
+	 * a concurrency level of CONCUR_READ_ONLY. The holdability of the created result sets can be determined by calling getHoldability().
-}
+	 *
-MonetSavepoint sp = (MonetSavepoint) savepoint;
+	 * Parameters:
-// note: can't use sendIndependentCommand here because we need
+	 *     sql - an SQL statement that may contain one or more '?' IN parameter placeholders
-// to process the auto_commit state the server gives
+	 *     columnIndexes - an array of column indexes indicating the columns that should be returned from the inserted row or rows
-// create a container for the result
+	 * Returns:
-this.createResponseList("RELEASE SAVEPOINT " + sp.getName());
+	 *     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
-* Undoes all changes made in the current transaction and releases
+	 *     SQLFeatureNotSupportedException - if the JDBC driver does not support this method
-* any database locks currently held by this Connection object. This
+	 */
-* method should be used only when auto-commit mode has been
+	@Override
-* disabled.
+	public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
-*
+		throw new SQLFeatureNotSupportedException("prepareStatement(String sql, int[] columnIndexes) not supported", "0A000");
-* @throws SQLException if a database access error occurs or this
+	}
-*         Connection object is in auto-commit mode
-* @see #setAutoCommit(boolean)
+	/**
-*/
+	 * Creates a default PreparedStatement object capable of returning the auto-generated keys designated by the given array.
-@Override
+	 * This array contains the names of the columns in the target table that contain the auto-generated keys that should be returned.
-public void rollback() throws SQLException {
+	 * The driver will ignore the array if the SQL statement is not an INSERT statement, or an SQL statement able to
-// note: can't use sendIndependentCommand here because we need
+	 * return auto-generated keys (the list of such statements is vendor-specific).
-// to process the auto_commit state the server gives
+	 *
-// create a container for the result
+	 * An SQL statement with or without IN parameters can be pre-compiled and stored in a PreparedStatement object.
-this.createResponseList("ROLLBACK");
+	 * 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.
-* Undoes all changes made after the given Savepoint object was set.
+	 * 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.
-* This method should be used only when auto-commit has been
+	 *
-* disabled.
+	 * 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().
-* @param savepoint the Savepoint object to roll back to
+	 *
-* @throws SQLException if a database access error occurs, the
+	 * Parameters:
-*         Savepoint object is no longer valid, or this Connection
+	 *     sql - an SQL statement that may contain one or more '?' IN parameter placeholders
-*         object is currently in auto-commit mode
+	 *     columnNames - an array of column names indicating the columns that should be returned from the inserted row or rows
-*/
+	 * Returns:
-@Override
+	 *     a new PreparedStatement object, containing the pre-compiled statement, that is capable of
-public void rollback(Savepoint savepoint) throws SQLException {
+	 *     returning the auto-generated keys designated by the given array of column names
-if (!(savepoint instanceof MonetSavepoint)) {
+	 * Throws:
-throw new SQLException("This driver can only handle savepoints it created itself", "M0M06");
+	 *     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
+	 */
-MonetSavepoint sp = (MonetSavepoint)savepoint;
+	@Override
-// note: can't use sendIndependentCommand here because we need
+	public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
-// to process the auto_commit state the server gives
+		throw new SQLFeatureNotSupportedException("prepareStatement(String sql, String[] columnNames) not supported", "0A000");
-// create a container for the result
+	}
-this.createResponseList("ROLLBACK TO SAVEPOINT " + sp.getName());
-}
+	/**
+	 * Removes the given Savepoint object from the current transaction.
-/**
+	 * Any reference to the savepoint after it have been removed will
-* Sets this connection's auto-commit mode to the given state. If a
+	 * cause an SQLException to be thrown.
-* connection is in auto-commit mode, then all its SQL statements
+	 *
-* will be executed and committed as individual transactions.
+	 * @param savepoint the Savepoint object to be removed
-* Otherwise, its SQL statements are grouped into transactions that
+	 * @throws SQLException if a database access error occurs or the given
-* are terminated by a call to either the method commit or the
+	 *         Savepoint object is not a valid savepoint in the current
-* method rollback. By default, new connections are in auto-commit
+	 *         transaction
-* mode.
+	 */
-*
+	@Override
-* The commit occurs when the statement completes or the next
+	public void releaseSavepoint(Savepoint savepoint) throws SQLException {
-* execute occurs, whichever comes first. In the case of statements
+		if (!(savepoint instanceof MonetSavepoint)) {
-* returning a ResultSet object, the statement completes when the
+			throw new SQLException("This driver can only handle savepoints it created itself", "M0M06");
-* last row of the ResultSet object has been retrieved or the
+		}
-* ResultSet object has been closed. In advanced cases, a single
+		MonetSavepoint sp = (MonetSavepoint) savepoint;
-* statement may return multiple results as well as output parameter
+		// note: can't use sendIndependentCommand here because we need
-* values. In these cases, the commit occurs when all results and
+		// to process the auto_commit state the server gives
-* output parameter values have been retrieved.
+		this.sendTransactionCommand("RELEASE SAVEPOINT " + sp.getName());
-*
+	}
-* NOTE: If this method is called during a transaction, the
-* transaction is committed.
+	/**
-*
+	 * Undoes all changes made in the current transaction and releases
-* @param autoCommit true to enable auto-commit mode; false to disable it
+	 * any database locks currently held by this Connection object. This
-* @throws SQLException if a database access error occurs
+	 * method should be used only when auto-commit mode has been
-* @see #getAutoCommit()
+	 * disabled.
-*/
+	 *
-@Override
+	 * @throws SQLException if a database access error occurs or this
-public void setAutoCommit(boolean autoCommit) throws SQLException {
+	 *         Connection object is in auto-commit mode
-if (this.autoCommit != autoCommit) {
+	 * @see #setAutoCommit(boolean)
-this.sendControlCommand(ControlCommands.AUTO_COMMIT, (autoCommit ? 1 : 0));
+	 */
-this.autoCommit = autoCommit;
+	@Override
-}
+	public void rollback() throws SQLException {
-}
+		// note: can't use sendIndependentCommand here because we need
+		// to process the auto_commit state the server gives
-/**
+		// create a container for the result
-* Sets the given catalog name in order to select a subspace of this
+		this.sendTransactionCommand("ROLLBACK");
-* Connection object's database in which to work.  If the driver
+	}
-* does not support catalogs, it will silently ignore this request.
-*/
+	/**
-@Override
+	 * Undoes all changes made after the given Savepoint object was set.
-public void setCatalog(String catalog) throws SQLException {
+	 *
-throw new SQLFeatureNotSupportedException("setCatalog(String catalog) not supported", "0A000");
+	 * This method should be used only when auto-commit has been
-}
+	 * disabled.
+	 *
-/**
+	 * @param savepoint the Savepoint object to roll back to
-* Changes the default holdability of ResultSet objects created using this
+	 * @throws SQLException if a database access error occurs, the
-* Connection object to the given holdability. The default holdability of
+	 *         Savepoint object is no longer valid, or this Connection
-* ResultSet objects can be be determined by invoking DatabaseMetaData.getResultSetHoldability().
+	 *         object is currently in auto-commit mode
-*
+	 */
-* @param holdability - a ResultSet holdability constant; one of
+	@Override
-*	ResultSet.HOLD_CURSORS_OVER_COMMIT or
+	public void rollback(Savepoint savepoint) throws SQLException {
-*	ResultSet.CLOSE_CURSORS_AT_COMMIT
+		if (!(savepoint instanceof MonetSavepoint)) {
-* @see #getHoldability()
+			throw new SQLException("This driver can only handle savepoints it created itself", "M0M06");
-*/
+		}
-@Override
-public void setHoldability(int holdability) throws SQLException {
+		MonetSavepoint sp = (MonetSavepoint)savepoint;
-// we only support ResultSet.HOLD_CURSORS_OVER_COMMIT
+		// note: can't use sendIndependentCommand here because we need
-if (holdability != ResultSet.HOLD_CURSORS_OVER_COMMIT)
+		// to process the auto_commit state the server gives
-throw new SQLFeatureNotSupportedException("setHoldability(CLOSE_CURSORS_AT_COMMIT) not supported", "0A000");
+		// create a container for the result
-}
+		this.sendTransactionCommand("ROLLBACK TO SAVEPOINT " + sp.getName());
+	}
-/**
-* Puts this connection in read-only mode as a hint to the driver to
+	/**
-* enable database optimizations.  MonetDB doesn't support any mode
+	 * Sets this connection's auto-commit mode to the given state. If a
-* here, hence an SQLWarning is generated if attempted to set
+	 * connection is in auto-commit mode, then all its SQL statements
-* to true here.
+	 * will be executed and committed as individual transactions.
-*
+	 * Otherwise, its SQL statements are grouped into transactions that
-* @param readOnly true enables read-only mode; false disables it
+	 * are terminated by a call to either the method commit or the
-* @throws SQLException if a database access error occurs or this
+	 * method rollback. By default, new connections are in auto-commit
-*         method is called during a transaction.
+	 * mode.
-*/
+	 *
-@Override
+	 * The commit occurs when the statement completes or the next
-public void setReadOnly(boolean readOnly) throws SQLException {
+	 * execute occurs, whichever comes first. In the case of statements
-if (readOnly) {
+	 * returning a ResultSet object, the statement completes when the
-addWarning("cannot setReadOnly(true): read-only Connection mode not supported", "01M08");
+	 * last row of the ResultSet object has been retrieved or the
-}
+	 * ResultSet object has been closed. In advanced cases, a single
-}
+	 * statement may return multiple results as well as output parameter
+	 * values. In these cases, the commit occurs when all results and
-/**
+	 * output parameter values have been retrieved.
-* Creates an unnamed savepoint in the current transaction and
+	 *
-* returns the new Savepoint object that represents it.
+	 * NOTE: If this method is called during a transaction, the
-*
+	 * transaction is committed.
-* @return the new Savepoint object
+	 *
-* @throws SQLException if a database access error occurs or this Connection
+	 * @param autoCommit true to enable auto-commit mode; false to disable it
-*         object is currently in auto-commit mode
+	 * @throws SQLException if a database access error occurs
-*/
+	 * @see #getAutoCommit()
-@Override
+	 */
-public Savepoint setSavepoint() throws SQLException {
+	@Override
-// create a new Savepoint object
+	public void setAutoCommit(boolean autoCommit) throws SQLException {
-MonetSavepoint sp = new MonetSavepoint();
+		if (this.autoCommit != autoCommit) {
-// note: can't use sendIndependentCommand here because we need
+			this.sendControlCommand(ControlCommands.AUTO_COMMIT, (autoCommit ? 1 : 0));
-// to process the auto_commit state the server gives
+			this.autoCommit = autoCommit;
-// create a container for the result
+		}
-this.createResponseList("SAVEPOINT " + sp.getName());
+	}
-return sp;
-}
+	/**
+	 * Sets the given catalog name in order to select a subspace of this
-/**
+	 * Connection object's database in which to work.  If the driver
-* Creates a savepoint with the given name in the current
+	 * does not support catalogs, it will silently ignore this request.
-* transaction and returns the new Savepoint object that represents
+	 */
-* it.
+	@Override
-*
+	public void setCatalog(String catalog) throws SQLException {
-* @param name a String containing the name of the savepoint
+		throw new SQLFeatureNotSupportedException("setCatalog(String catalog) not supported", "0A000");
-* @return the new Savepoint object
+	}
-* @throws SQLException if a database access error occurs or this Connection
-*         object is currently in auto-commit mode
+	/**
-*/
+	 * Changes the default holdability of ResultSet objects created using this
-@Override
+	 * Connection object to the given holdability. The default holdability of
-public Savepoint setSavepoint(String name) throws SQLException {
+	 * ResultSet objects can be be determined by invoking DatabaseMetaData.getResultSetHoldability().
-// create a new Savepoint object
+	 *
-MonetSavepoint sp;
+	 * @param holdability - a ResultSet holdability constant; one of
-try {
+	 *	ResultSet.HOLD_CURSORS_OVER_COMMIT or
-sp = new MonetSavepoint(name);
+	 *	ResultSet.CLOSE_CURSORS_AT_COMMIT
-} catch (IllegalArgumentException e) {
+	 * @see #getHoldability()
-throw new SQLException(e.getMessage(), "M0M03");
+	 */
-}
+	@Override
-// note: can't use sendIndependentCommand here because we need
+	public void setHoldability(int holdability) throws SQLException {
-// to process the auto_commit state the server gives
+		// we only support ResultSet.HOLD_CURSORS_OVER_COMMIT
-// create a container for the result
+		if (holdability != ResultSet.HOLD_CURSORS_OVER_COMMIT)
-this.createResponseList("SAVEPOINT " + sp.getName());
+			throw new SQLFeatureNotSupportedException("setHoldability(CLOSE_CURSORS_AT_COMMIT) not supported", "0A000");
-return sp;
+	}
-}
+	/**
-/**
+	 * Puts this connection in read-only mode as a hint to the driver to
-* Attempts to change the transaction isolation level for this
+	 * enable database optimizations.  MonetDB doesn't support any mode
-* Connection object to the one given.  The constants defined in the
+	 * here, hence an SQLWarning is generated if attempted to set
-* interface Connection are the possible transaction isolation
+	 * to true here.
-* levels.
+	 *
-*
+	 * @param readOnly true enables read-only mode; false disables it
-* @param level one of the following Connection constants: Connection.TRANSACTION_READ_UNCOMMITTED,
+	 * @throws SQLException if a database access error occurs or this
-*        Connection.TRANSACTION_READ_COMMITTED, Connection.TRANSACTION_REPEATABLE_READ, or
+	 *         method is called during a transaction.
-*        Connection.TRANSACTION_SERIALIZABLE.
+	 */
-*/
+	@Override
-@Override
+	public void setReadOnly(boolean readOnly) throws SQLException {
-public void setTransactionIsolation(int level) {
+		if (readOnly) {
-if (level != TRANSACTION_SERIALIZABLE) {
+			addWarning("cannot setReadOnly(true): read-only Connection mode not supported", "01M08");
-addWarning("MonetDB only supports fully serializable " +
+		}
-"transactions, continuing with transaction level raised to TRANSACTION_SERIALIZABLE", "01M09");
+	}
-}
-}
+	/**
+	 * Creates an unnamed savepoint in the current transaction and
-/**
+	 * returns the new Savepoint object that represents it.
-* Installs the given TypeMap object as the type map for this
+	 *
-* Connection object. The type map will be used for the custom
+	 * @return the new Savepoint object
-* mapping of SQL structured types and distinct types.
+	 * @throws SQLException if a database access error occurs or this Connection
-*
+	 *         object is currently in auto-commit mode
-* @param map the java.util.Map object to install as the replacement for
+	 */
-*        this Connection  object's default type map
+	@Override
-*/
+	public Savepoint setSavepoint() throws SQLException {
-@Override
+		// create a new Savepoint object
-public void setTypeMap(Map<String, Class<?>> map) {
+		MonetSavepoint sp = new MonetSavepoint();
-typeMap = map;
+		// note: can't use sendIndependentCommand here because we need
-}
+		// to process the auto_commit state the server gives
+		// create a container for the result
-/**
+		this.sendTransactionCommand("SAVEPOINT " + sp.getName());
-* Returns a string identifying this Connection to the MonetDB server.
+		return sp;
-*
+	}
-* @return a String representing this Object
-*/
+	/**
-@Override
+	 * Creates a savepoint with the given name in the current
-public String toString() {
+	 * transaction and returns the new Savepoint object that represents
-return "MonetDB Connection (" + this.getJDBCURL() + ") " + (closed ? "disconnected" : "connected");
+	 * it.
-}
+	 *
+	 * @param name a String containing the name of the savepoint
-//== Java 1.6 methods (JDBC 4.0)
+	 * @return the new Savepoint object
+	 * @throws SQLException if a database access error occurs or this Connection
-/**
+	 *         object is currently in auto-commit mode
-* Factory method for creating Array objects.
+	 */
-*
+	@Override
-* Note: When createArrayOf is used to create an array object that
+	public Savepoint setSavepoint(String name) throws SQLException {
-* maps to a primitive data type, then it is implementation-defined
+		// create a new Savepoint object
-* whether the Array object is an array of that primitive data type
+		MonetSavepoint sp;
-* or an array of Object.
+		try {
-*
+			sp = new MonetSavepoint(name);
-* Note: The JDBC driver is responsible for mapping the elements
+		} catch (IllegalArgumentException e) {
-* Object array to the default JDBC SQL type defined in
+			throw new SQLException(e.getMessage(), "M0M03");
-* java.sql.Types for the given class of Object. The default mapping
+		}
-* is specified in Appendix B of the JDBC specification. If the
+		// note: can't use sendIndependentCommand here because we need
-* resulting JDBC type is not the appropriate type for the given
+		// to process the auto_commit state the server gives
-* typeName then it is implementation defined whether an
+		// create a container for the result
-* SQLException is thrown or the driver supports the resulting conversion.
+		this.sendTransactionCommand("SAVEPOINT " + sp.getName());
-*
+		return sp;
-* @param typeName the SQL name of the type the elements of the
+	}
-*        array map to. The typeName is a database-specific name
-*        which may be the name of a built-in type, a user-defined
+	/**
-*        type or a standard SQL type supported by this database.
+	 * Attempts to change the transaction isolation level for this
-*        This is the value returned by Array.getBaseTypeName
+	 * Connection object to the one given.  The constants defined in the
-* @return an Array object whose elements map to the specified SQL type
+	 * interface Connection are the possible transaction isolation
-* @throws SQLException if a database error occurs, the JDBC type
+	 * levels.
-*         is not appropriate for the typeName and the conversion is
+	 *
-*         not supported, the typeName is null or this method is
+	 * @param level one of the following Connection constants: Connection.TRANSACTION_READ_UNCOMMITTED,
-*         called on a closed connection
+	 *        Connection.TRANSACTION_READ_COMMITTED, Connection.TRANSACTION_REPEATABLE_READ, or
-* @throws SQLFeatureNotSupportedException the JDBC driver does
+	 *        Connection.TRANSACTION_SERIALIZABLE.
-*         not support this data type
+	 */
-* @since 1.6
+	@Override
-*/
+	public void setTransactionIsolation(int level) {
-@Override
+		if (level != TRANSACTION_SERIALIZABLE) {
-public java.sql.Array createArrayOf(String typeName, Object[] elements) throws SQLException {
+			addWarning("MonetDB only supports fully serializable " +
-throw new SQLFeatureNotSupportedException("createArrayOf() not supported", "0A000");
+					"transactions, continuing with transaction level raised to TRANSACTION_SERIALIZABLE", "01M09");
-}
+		}
+	}
-/**
-* Constructs an object that implements the Clob interface. The
+	/**
-* object returned initially contains no data. The setAsciiStream,
+	 * Installs the given TypeMap object as the type map for this
-* setCharacterStream and setString methods of the Clob interface
+	 * Connection object. The type map will be used for the custom
-* may be used to add data to the Clob.
+	 * mapping of SQL structured types and distinct types.
-*
+	 *
-* @return a MonetClob instance
+	 * @param map the java.util.Map object to install as the replacement for
-* @throws SQLFeatureNotSupportedException the JDBC driver does
+	 *        this Connection  object's default type map
-*         not support MonetClob objects that can be filled in
+	 */
-* @since 1.6
+	@Override
-*/
+	public void setTypeMap(Map<String, Class<?>> map) {
-@Override
+		typeMap = map;
-public java.sql.Clob createClob() throws SQLException {
+	}
-return new MonetClob("");
-}
+	/**
+	 * Returns a string identifying this Connection to the MonetDB server.
-/**
+	 *
-* Constructs an object that implements the Blob interface. The
+	 * @return a String representing this Object
-* object returned initially contains no data. The setBinaryStream
+	 */
-* and setBytes methods of the Blob interface may be used to add
+	@Override
-* data to the Blob.
+	public String toString() {
-*
+		return "MonetDB Connection (" + this.getJDBCURL() + ") " + (closed ? "disconnected" : "connected");
-* @return a MonetBlob instance
+	}
-* @throws SQLFeatureNotSupportedException the JDBC driver does
-*         not support MonetBlob objects that can be filled in
+	/**
-* @since 1.6
+	 * Factory method for creating Array objects.
-*/
+	 *
-@Override
+	 * Note: When createArrayOf is used to create an array object that
-public java.sql.Blob createBlob() throws SQLException {
+	 * maps to a primitive data type, then it is implementation-defined
-return new MonetBlob(new byte[1]);
+	 * whether the Array object is an array of that primitive data type
-}
+	 * or an array of Object.
+	 *
-/**
+	 * Note: The JDBC driver is responsible for mapping the elements
-* Constructs an object that implements the NClob interface. The
+	 * Object array to the default JDBC SQL type defined in
-* object returned initially contains no data. The setAsciiStream,
+	 * java.sql.Types for the given class of Object. The default mapping
-* setCharacterStream and setString methods of the NClob interface
+	 * is specified in Appendix B of the JDBC specification. If the
-* may be used to add data to the NClob.
+	 * resulting JDBC type is not the appropriate type for the given
-*
+	 * typeName then it is implementation defined whether an
-* @return an NClob instance
+	 * SQLException is thrown or the driver supports the resulting conversion.
-* @throws SQLFeatureNotSupportedException the JDBC driver does
+	 *
-*         not support MonetNClob objects that can be filled in
+	 * @param typeName the SQL name of the type the elements of the
-* @since 1.6
+	 *        array map to. The typeName is a database-specific name
-*/
+	 *        which may be the name of a built-in type, a user-defined
-@Override
+	 *        type or a standard SQL type supported by this database.
-public java.sql.NClob createNClob() throws SQLException {
+	 *        This is the value returned by Array.getBaseTypeName
-throw new SQLFeatureNotSupportedException("createNClob() not supported", "0A000");
+	 * @return an Array object whose elements map to the specified SQL type
-}
+	 * @throws SQLException if a database error occurs, the JDBC type
+	 *         is not appropriate for the typeName and the conversion is
-/**
+	 *         not supported, the typeName is null or this method is
-* Factory method for creating Struct objects.
+	 *         called on a closed connection
-*
+	 * @throws SQLFeatureNotSupportedException the JDBC driver does
-* @param typeName the SQL type name of the SQL structured type that
+	 *         not support this data type
-*        this Struct object maps to. The typeName is the name of a
+	 * @since 1.6
-*        user-defined type that has been defined for this database.
+	 */
-*        It is the value returned by Struct.getSQLTypeName.
+	@Override
-* @param attributes the attributes that populate the returned object
+	public java.sql.Array createArrayOf(String typeName, Object[] elements) throws SQLException {
-* @return a Struct object that maps to the given SQL type and is
+		throw new SQLFeatureNotSupportedException("createArrayOf() not supported", "0A000");
-*         populated with the given attributes
+	}
-* @throws SQLException if a database error occurs, the typeName
-*         is null or this method is called on a closed connection
-* @throws SQLFeatureNotSupportedException the JDBC driver does
+	//== end methods of interface java.sql.Connection
-*         not support this data type
-* @since 1.6
+	/**
-*/
+	 * Constructs an object that implements the Clob interface. The
-@Override
+	 * object returned initially contains no data. The setAsciiStream,
-public java.sql.Struct createStruct(String typeName, Object[] attributes) throws SQLException {
+	 * setCharacterStream and setString methods of the Clob interface
-throw new SQLFeatureNotSupportedException("createStruct() not supported", "0A000");
+	 * may be used to add data to the Clob.
-}
+	 *
+	 * @return a MonetClob instance
-/**
+	 * @throws SQLFeatureNotSupportedException the JDBC driver does
-* Constructs an object that implements the SQLXML interface. The
+	 *         not support MonetClob objects that can be filled in
-* object returned initially contains no data. The
+	 * @since 1.6
-* createXmlStreamWriter object and setString method of the SQLXML
+	 */
-* interface may be used to add data to the SQLXML object.
+	@Override
-*
+	public java.sql.Clob createClob() throws SQLException {
-* @return An object that implements the SQLXML interface
+		return new MonetClob("");
-* @throws SQLFeatureNotSupportedException the JDBC driver does
+	}
-*         not support this data type
-* @since 1.6
+	/**
-*/
+	 * Constructs an object that implements the Blob interface. The
-@Override
+	 * object returned initially contains no data. The setBinaryStream
-public java.sql.SQLXML createSQLXML() throws SQLException {
+	 * and setBytes methods of the Blob interface may be used to add
-throw new SQLFeatureNotSupportedException("createSQLXML() not supported", "0A000");
+	 * data to the Blob.
-}
+	 *
+	 * @return a MonetBlob instance
-/**
+	 * @throws SQLFeatureNotSupportedException the JDBC driver does
-* Returns true if the connection has not been closed and is still
+	 *         not support MonetBlob objects that can be filled in
-* valid. The driver shall submit a query on the connection or use
+	 * @since 1.6
-* some other mechanism that positively verifies the connection is
+	 */
-* still valid when this method is called.
+	@Override
-*
+	public java.sql.Blob createBlob() throws SQLException {
-* The query submitted by the driver to validate the connection
+		return new MonetBlob(new byte[1]);
-* shall be executed in the context of the current transaction.
+	}
-*
-* @param timeout The time in seconds to wait for the database
+	/**
-*        operation used to validate the connection to complete. If
+	 * Constructs an object that implements the NClob interface. The
-*        the timeout period expires before the operation completes,
+	 * object returned initially contains no data. The setAsciiStream,
-*        this method returns false. A value of 0 indicates a
+	 * setCharacterStream and setString methods of the NClob interface
-*        timeout is not applied to the database operation.
+	 * may be used to add data to the NClob.
-* @return true if the connection is valid, false otherwise
+	 *
-* @throws SQLException if the value supplied for timeout is less than 0
+	 * @return an NClob instance
-* @since 1.6
+	 * @throws SQLFeatureNotSupportedException the JDBC driver does
-*/
+	 *         not support MonetNClob objects that can be filled in
-@Override
+	 * @since 1.6
-public boolean isValid(int timeout) throws SQLException {
+	 */
-if (timeout < 0)
+	@Override
-throw new SQLException("timeout is less than 0", "M1M05");
+	public java.sql.NClob createNClob() throws SQLException {
-if (closed)
+		throw new SQLFeatureNotSupportedException("createNClob() not supported", "0A000");
-return false;
+	}
-// ping db using query: select 1;
+	/**
-Statement stmt = null;
+	 * Factory method for creating Struct objects.
-ResultSet rs = null;
+	 *
-try {
+	 * @param typeName the SQL type name of the SQL structured type that
-stmt = createStatement();
+	 *        this Struct object maps to. The typeName is the name of a
-stmt.setQueryTimeout(timeout);
+	 *        user-defined type that has been defined for this database.
-rs = stmt.executeQuery("SELECT 1");
+	 *        It is the value returned by Struct.getSQLTypeName.
-rs.close();
+	 * @param attributes the attributes that populate the returned object
-rs = null;
+	 * @return a Struct object that maps to the given SQL type and is
-stmt.close();
+	 *         populated with the given attributes
-return true;
+	 * @throws SQLException if a database error occurs, the typeName
-} catch (Exception e) {
+	 *         is null or this method is called on a closed connection
-if (rs != null) {
+	 * @throws SQLFeatureNotSupportedException the JDBC driver does
-try {
+	 *         not support this data type
-rs.close();
+	 * @since 1.6
-} catch (Exception ignored) {}
+	 */
-}
+	@Override
-if (stmt != null) {
+	public java.sql.Struct createStruct(String typeName, Object[] attributes) throws SQLException {
-try {
+		throw new SQLFeatureNotSupportedException("createStruct() not supported", "0A000");
-stmt.close();
+	}
-} catch (Exception ignored) {}
-}
+	/**
-}
+	 * Constructs an object that implements the SQLXML interface. The
-return false;
+	 * object returned initially contains no data. The
-}
+	 * createXmlStreamWriter object and setString method of the SQLXML
+	 * interface may be used to add data to the SQLXML object.
-/**
+	 *
-* Returns the value of the client info property specified by name.
+	 * @return An object that implements the SQLXML interface
-* This method may return null if the specified client info property
+	 * @throws SQLFeatureNotSupportedException the JDBC driver does
-* has not been set and does not have a default value.
+	 *         not support this data type
-* This method will also return null if the specified client info
+	 * @since 1.6
-* property name is not supported by the driver.
+	 */
-* Applications may use the DatabaseMetaData.getClientInfoProperties method
+	@Override
-* to determine the client info properties supported by the driver.
+	public java.sql.SQLXML createSQLXML() throws SQLException {
-*
+		throw new SQLFeatureNotSupportedException("createSQLXML() not supported", "0A000");
-* @param name - The name of the client info property to retrieve
+	}
-* @return The value of the client info property specified or null
-* @throws SQLException - if the database server returns an error
+	/**
-*	when fetching the client info value from the database
+	 * Returns true if the connection has not been closed and is still
-*	or this method is called on a closed connection
+	 * valid. The driver shall submit a query on the connection or use
-* @since 1.6
+	 * some other mechanism that positively verifies the connection is
-*/
+	 * still valid when this method is called.
-@Override
+	 *
-public String getClientInfo(String name) throws SQLException {
+	 * The query submitted by the driver to validate the connection
-if (name == null || name.isEmpty())
+	 * shall be executed in the context of the current transaction.
-return null;
+	 *
-return conn_props.getProperty(name);
+	 * @param timeout The time in seconds to wait for the database
-}
+	 *        operation used to validate the connection to complete. If
+	 *        the timeout period expires before the operation completes,
-/**
+	 *        this method returns false. A value of 0 indicates a
-* Returns a list containing the name and current value of each client info
+	 *        timeout is not applied to the database operation.
-* property supported by the driver. The value of a client info property may
+	 * @return true if the connection is valid, false otherwise
-* be null if the property has not been set and does not have a default value.
+	 * @throws SQLException if the value supplied for timeout is less than 0
-*
+	 * @since 1.6
-* @return A Properties object that contains the name and current value
+	 */
-*         of each of the client info properties supported by the driver.
+	@Override
-* @throws SQLException - if the database server returns an error
+	public boolean isValid(int timeout) throws SQLException {
-*	when fetching the client info value from the database
+		if (timeout < 0)
-*	or this method is called on a closed connection
+			throw new SQLException("timeout is less than 0", "M1M05");
-* @since 1.6
+		if (closed)
-*/
+			return false;
-@Override
-public Properties getClientInfo() throws SQLException {
+		// ping db using query: select 1;
-// return a clone of the connection properties object
+		Statement stmt = null;
-return new Properties(conn_props);
+		ResultSet rs = null;
-}
+		boolean isValid = false;
+		try {
-/**
+			stmt = createStatement();
-* Sets the value of the client info property specified by name to the value specified by value.
+			if (stmt != null) {
-* Applications may use the DatabaseMetaData.getClientInfoProperties method to determine
+				int original_timeout = stmt.getQueryTimeout();
-* the client info properties supported by the driver and the maximum length that may be specified
+				if (timeout > 0 && original_timeout != timeout) {
-* for each property.
+					// we need to change the requested timeout for this test query
-*
+					stmt.setQueryTimeout(timeout);
-* The driver stores the value specified in a suitable location in the database. For example
+				}
-* in a special register, session parameter, or system table column. For efficiency the driver
+				rs = stmt.executeQuery("SELECT 1");
-* may defer setting the value in the database until the next time a statement is executed
+				if (rs != null && rs.next()) {
-* or prepared. Other than storing the client information in the appropriate place in the
+					isValid = true;
-* database, these methods shall not alter the behavior of the connection in anyway.
+				}
-* The values supplied to these methods are used for accounting, diagnostics and debugging purposes only.
+				if (timeout > 0 && original_timeout != timeout) {
-*
+					// restore the original server timeout value
-* The driver shall generate a warning if the client info name specified is not recognized by the driver.
+					stmt.setQueryTimeout(original_timeout);
-*
+				}
-* If the value specified to this method is greater than the maximum length for the property
+			}
-* the driver may either truncate the value and generate a warning or generate a SQLClientInfoException.
+		} catch (SQLException se) {
-* If the driver generates a SQLClientInfoException, the value specified was not set on the connection.
+			String msg = se.getMessage();
-*
+			if (msg != null && msg.equals("Current transaction is aborted (please ROLLBACK)")) {
-* The following are standard client info properties. Drivers are not required to support these
+				isValid = true;
-* properties however if the driver supports a client info property that can be described by one
+			}
-* of the standard properties, the standard property name should be used.
+			/* ignore stmt errors/exceptions, we are only testing if the connection is still alive and usable */
-*
+		} finally {
-*	ApplicationName - The name of the application currently utilizing the connection
+			if (rs != null) {
-*	ClientUser - The name of the user that the application using the connection is performing work for.
+				try {
-*		This may not be the same as the user name that was used in establishing the connection.
+					rs.close();
-*	ClientHostname - The hostname of the computer the application using the connection is running on.
+				} catch (Exception e2) { /* ignore error */ }
-*
+			}
-* @param name - The name of the client info property to set
+			if (stmt != null) {
-* @param value - The value to set the client info property to. If the
+				try {
-*        value is null, the current value of the specified property is cleared.
+					stmt.close();
-* @throws SQLClientInfoException - if the database server returns an error
+				} catch (Exception e2) { /* ignore error */ }
-*         while setting the clientInfo values on the database server
+			}
-*         or this method is called on a closed connection
+		}
-* @since 1.6
+		return isValid;
-*/
+	}
-@Override
-public void setClientInfo(String name, String value) throws java.sql.SQLClientInfoException {
+	/**
-if (name == null || name.isEmpty()) {
+	 * Returns the value of the client info property specified by name.
-addWarning("setClientInfo: missing property name", "01M07");
+	 * This method may return null if the specified client info property
-return;
+	 * has not been set and does not have a default value.
-}
+	 * This method will also return null if the specified client info
-// If the value is null, the current value of the specified property is cleared.
+	 * property name is not supported by the driver.
-if (value == null) {
+	 * Applications may use the DatabaseMetaData.getClientInfoProperties method
-if (conn_props.containsKey(name))
+	 * to determine the client info properties supported by the driver.
-conn_props.remove(name);
+	 *
-return;
+	 * @param name - The name of the client info property to retrieve
-}
+	 * @return The value of the client info property specified or null
-// only set value for supported property names
+	 * @throws SQLException - if the database server returns an error
-if (name.equals("host") || name.equals("port") || name.equals("user") || name.equals("password") ||
+	 *	when fetching the client info value from the database
-name.equals("database") || name.equals("language") || name.equals("so_timeout") ||
+	 *	or this method is called on a closed connection
-name.equals("hash") || name.equals("treat_blob_as_binary") || name.equals("follow_redirects") ||
+	 * @since 1.6
-name.equals("treat_clob_as_longvarchar") || name.equals("embedded") || name.equals("directory")) {
+	 */
-conn_props.setProperty(name, value);
+	@Override
-} else {
+	public String getClientInfo(String name) throws SQLException {
-addWarning("setClientInfo: " + name + "is not a recognised property", "01M07");
+		if (name == null || name.isEmpty())
-}
+			return null;
-}
+		return conn_props.getProperty(name);
+	}
-/**
-* Sets the value of the connection's client info properties.
+	/**
-* The Properties object contains the names and values of the client info
+	 * Returns a list containing the name and current value of each client info
-* properties to be set. The set of client info properties contained in the
+	 * property supported by the driver. The value of a client info property may
-* properties list replaces the current set of client info properties on the connection.
+	 * be null if the property has not been set and does not have a default value.
-* If a property that is currently set on the connection is not present in the
+	 *
-* properties list, that property is cleared. Specifying an empty properties list
+	 * @return A Properties object that contains the name and current value
-* will clear all of the properties on the connection.
+	 *         of each of the client info properties supported by the driver.
-* See setClientInfo (String, String) for more information.
+	 * @throws SQLException - if the database server returns an error
-*
+	 *	when fetching the client info value from the database
-* If an error occurs in setting any of the client info properties, a
+	 *	or this method is called on a closed connection
-* SQLClientInfoException is thrown. The SQLClientInfoException contains information
+	 * @since 1.6
-* indicating which client info properties were not set. The state of the client
+	 */
-* information is unknown because some databases do not allow multiple client info
+	@Override
-* properties to be set atomically. For those databases, one or more properties may
+	public Properties getClientInfo() throws SQLException {
-* have been set before the error occurred.
+		// return a clone of the connection properties object
-*
+		return new Properties(conn_props);
-* @param props - The list of client info properties to set
+	}
-* @throws SQLClientInfoException - if the database server returns an error
-*	while setting the clientInfo values on the database server
+	/**
-*	or this method is called on a closed connection
+	 * Sets the value of the client info property specified by name to the value specified by value.
-* @since 1.6
+	 * Applications may use the DatabaseMetaData.getClientInfoProperties method to determine
-*/
+	 * the client info properties supported by the driver and the maximum length that may be specified
-@Override
+	 * for each property.
-public void setClientInfo(Properties props) throws java.sql.SQLClientInfoException {
+	 *
-if (props != null) {
+	 * The driver stores the value specified in a suitable location in the database. For example
-for (Map.Entry<Object, Object> entry : props.entrySet()) {
+	 * in a special register, session parameter, or system table column. For efficiency the driver
-setClientInfo(entry.getKey().toString(), entry.getValue().toString());
+	 * may defer setting the value in the database until the next time a statement is executed
-}
+	 * or prepared. Other than storing the client information in the appropriate place in the
-}
+	 * database, these methods shall not alter the behavior of the connection in anyway.
-}
+	 * The values supplied to these methods are used for accounting, diagnostics and debugging purposes only.
+	 *
-//== Java 1.7 methods (JDBC 4.1)
+	 * The driver shall generate a warning if the client info name specified is not recognized by the driver.
+	 *
-/**
+	 * If the value specified to this method is greater than the maximum length for the property
-* Sets the given schema name to access.
+	 * the driver may either truncate the value and generate a warning or generate a SQLClientInfoException.
-*
+	 * If the driver generates a SQLClientInfoException, the value specified was not set on the connection.
-* @param schema the name of a schema in which to work
+	 *
-* @throws SQLException if a database access error occurs or this method is called on a closed connection
+	 * The following are standard client info properties. Drivers are not required to support these
-* @since 1.7
+	 * properties however if the driver supports a client info property that can be described by one
-*/
+	 * of the standard properties, the standard property name should be used.
-@Override
+	 *
-public void setSchema(String schema) throws SQLException {
+	 *	ApplicationName - The name of the application currently utilizing the connection
-if (closed)
+	 *	ClientUser - The name of the user that the application using the connection is performing work for.
-throw new SQLException("Cannot call on closed Connection", "M1M20");
+	 *		This may not be the same as the user name that was used in establishing the connection.
-if (schema == null)
+	 *	ClientHostname - The hostname of the computer the application using the connection is running on.
-throw new SQLException("Missing schema name", "M1M05");
+	 *
+	 * @param name - The name of the client info property to set
-try (Statement st = createStatement()) {
+	 * @param value - The value to set the client info property to. If the
-st.execute("SET SCHEMA \"" + schema + "\"");
+	 *        value is null, the current value of the specified property is cleared.
-}
+	 * @throws SQLClientInfoException - if the database server returns an error
-}
+	 *         while setting the clientInfo values on the database server
+	 *         or this method is called on a closed connection
-/**
+	 * @since 1.6
-* Retrieves this Connection object's current schema name.
+	 */
-*
+	@Override
-* @return the current schema name or null if there is none
+	public void setClientInfo(String name, String value) throws java.sql.SQLClientInfoException {
-* @throws SQLException if a database access error occurs or this method is called on a closed connection
+		if (name == null || name.isEmpty()) {
-*/
+			addWarning("setClientInfo: missing property name", "01M07");
-@Override
+			return;
-public String getSchema() throws SQLException {
+		}
-if (closed) {
+		// If the value is null, the current value of the specified property is cleared.
-throw new SQLException("Cannot call on closed Connection", "M1M20");
+		if (value == null) {
-}
+			if (conn_props.containsKey(name))
-String cur_schema;
+				conn_props.remove(name);
-Statement st = createStatement();
+			return;
-ResultSet rs = null;
+		}
-try {
+		// only set value for supported property names
-rs = st.executeQuery("SELECT CURRENT_SCHEMA");
+		if (name.equals("host") || name.equals("port") || name.equals("user") || name.equals("password") ||
-if (!rs.next())
+				name.equals("database") || name.equals("language") || name.equals("so_timeout") ||
-throw new SQLException("Row expected", "02000");
+				name.equals("hash") || name.equals("treat_blob_as_binary") || name.equals("follow_redirects") ||
-cur_schema = rs.getString(1);
+				name.equals("treat_clob_as_longvarchar") || name.equals("embedded") || name.equals("directory")) {
-} finally {
+			conn_props.setProperty(name, value);
-if (rs != null)
+		} else {
-rs.close();
+			addWarning("setClientInfo: " + name + "is not a recognised property", "01M07");
-st.close();
+		}
-}
+	}
-return cur_schema;
-}
+	/**
+	 * Sets the value of the connection's client info properties.
-/**
+	 * The Properties object contains the names and values of the client info
-* Terminates an open connection. Calling abort results in:
+	 * properties to be set. The set of client info properties contained in the
-*  * The connection marked as closed
+	 * properties list replaces the current set of client info properties on the connection.
-*  * Closes any physical connection to the database
+	 * If a property that is currently set on the connection is not present in the
-*  * Releases resources used by the connection
+	 * properties list, that property is cleared. Specifying an empty properties list
-*  * Insures that any thread that is currently accessing the
+	 * will clear all of the properties on the connection.
-*    connection will either progress to completion or throw an
+	 * See setClientInfo (String, String) for more information.
-*    SQLException.
+	 *
-* Calling abort marks the connection closed and releases any
+	 * If an error occurs in setting any of the client info properties, a
-* resources. Calling abort on a closed connection is a no-op.
+	 * SQLClientInfoException is thrown. The SQLClientInfoException contains information
-*
+	 * indicating which client info properties were not set. The state of the client
-* @param executor The Executor implementation which will be used by abort
+	 * information is unknown because some databases do not allow multiple client info
-* @throws SQLException if a database access error occurs or the executor is null
+	 * properties to be set atomically. For those databases, one or more properties may
-* @throws SecurityException if a security manager exists and its checkPermission method denies calling abort
+	 * have been set before the error occurred.
-*/
+	 *
-@Override
+	 * @param props - The list of client info properties to set
-public void abort(Executor executor) throws SQLException {
+	 * @throws SQLClientInfoException - if the database server returns an error
-if (closed)
+	 *	while setting the clientInfo values on the database server
-return;
+	 *	or this method is called on a closed connection
-if (executor == null)
+	 * @since 1.6
-throw new SQLException("executor is null", "M1M05");
+	 */
-// this is really the simplest thing to do, it destroys
+	@Override
-// everything (in particular the server connection)
+	public void setClientInfo(Properties props) throws java.sql.SQLClientInfoException {
-close();
+		if (props != null) {
-}
+			for (Map.Entry<Object, Object> entry : props.entrySet()) {
+				setClientInfo(entry.getKey().toString(), entry.getValue().toString());
-/**
+			}
-* Sets the maximum period a Connection or objects created from the
+		}
-* Connection will wait for the database to reply to any one
+	}
-* request. If any request remains unanswered, the waiting method
-* will return with a SQLException, and the Connection or objects
+	/**
-* created from the Connection will be marked as closed. Any
+	 * Sets the given schema name to access.
-* subsequent use of the objects, with the exception of the close,
+	 *
-* isClosed or Connection.isValid methods, will result in a
+	 * @param schema the name of a schema in which to work
-* SQLException.
+	 * @throws SQLException if a database access error occurs or this method is called on a closed connection
-*
+	 * @since 1.7
-* @param executor The Executor implementation which will be used by setNetworkTimeout
+	 */
-* @param millis The time in milliseconds to wait for the database operation to complete
+	@Override
-* @throws SQLException if a database access error occurs, this method is called on a closed connection, the
+	public void setSchema(String schema) throws SQLException {
-* executor is null, or the value specified for seconds is less than 0.
+		if (closed)
-*/
+			throw new SQLException("Cannot call on closed Connection", "M1M20");
-@Override
+		if (schema == null)
-public void setNetworkTimeout(Executor executor, int millis) throws SQLException {
+			throw new SQLException("Missing schema name", "M1M05");
-if (closed) {
-throw new SQLException("Cannot call on closed Connection", "M1M20");
+		Statement st = createStatement();
-}
+		schema = schema.replaceAll("\\\\", "\\\\\\\\").replaceAll("'", "\\\\'");
-if (executor == null)
+		try {
-throw new SQLException("executor is null", "M1M05");
+			st.execute("SET SCHEMA \"" + schema + "\"");
-if (millis < 0)
+		} finally {
-throw new SQLException("milliseconds is less than zero", "M1M05");
+			st.close();
-this.setSoTimeout(millis);
+		}
-}
+	}
-/**
+	/**
-* Retrieves the number of milliseconds the driver will wait for a database request to complete. If the limit is
+	 * Retrieves this Connection object's current schema name.
-* exceeded, a SQLException is thrown.
+	 *
-*
+	 * @return the current schema name or null if there is none
-* @return the current timeout limit in milliseconds; zero means there is no limit
+	 * @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
+	 */
-*/
+	@Override
-@Override
+	public String getSchema() throws SQLException {
-public int getNetworkTimeout() throws SQLException {
+		if (closed) {
-if (closed) {
+			throw new SQLException("Cannot call on closed Connection", "M1M20");
-throw new SQLException("Cannot call on closed Connection", "M1M20");
+		}
-}
+		String cur_schema;
-return this.getSoTimeout();
+		Statement st = createStatement();
-}
+		ResultSet rs = null;
+		try {
-//== end methods of interface Connection
+			rs = st.executeQuery("SELECT CURRENT_SCHEMA");
+			if (!rs.next())
-/**
+				throw new SQLException("Row expected", "02000");
-* Returns whether the BLOB type should be mapped to BINARY type.
+			cur_schema = rs.getString(1);
-*/
+		} finally {
-public boolean getBlobAsBinary() {
+			if (rs != null)
-return blobIsBinary;
+				rs.close();
-}
+			st.close();
+		}
-/**
+		return cur_schema;
-* Returns whether the CLOB type should be mapped to LONGVARCHAR type.
+	}
-*/
-public boolean getClobAsLongChar() {
+	/**
-return clobIsLongChar;
+	 * Terminates an open connection. Calling abort results in:
-}
+	 *  * The connection marked as closed
+	 *  * Closes any physical connection to the database
-/**
+	 *  * Releases resources used by the connection
-* Sends the given string to MonetDB as regular statement, making sure there is a prompt after the command is sent.
+	 *  * Insures that any thread that is currently accessing the
-* All possible returned information is discarded. Encountered errors are reported.
+	 *    connection will either progress to completion or throw an
-*
+	 *    SQLException.
-* @param command the exact string to send to MonetDB
+	 * Calling abort marks the connection closed and releases any
-* @throws SQLException if an IO exception or a database error occurs
+	 * resources. Calling abort on a closed connection is a no-op.
-*/
+	 *
-void sendIndependentCommand(String command) throws SQLException {
+	 * @param executor The Executor implementation which will be used by abort
-try {
+	 * @throws SQLException if a database access error occurs or the executor is null
-protocol.writeNextQuery(language.getQueryTemplateIndex(0), command, language.getQueryTemplateIndex(1));
+	 * @throws SecurityException if a security manager exists and its checkPermission method denies calling abort
-protocol.waitUntilPrompt();
+	 */
-int csrh = protocol.getCurrentServerResponse();
+	@Override
-if (csrh == ServerResponses.ERROR) {
+	public void abort(Executor executor) throws SQLException {
-String error = protocol.getRemainingStringLine(0);
+		if (closed)
-throw new SQLException(error.substring(6), error.substring(0, 5));
+			return;
-}
+		if (executor == null)
-} catch (SocketTimeoutException e) {
+			throw new SQLException("executor is null", "M1M05");
-close(); // JDBC 4.1 semantics: abort()
+		// this is really the simplest thing to do, it destroys
-throw new SQLException("connection timed out", "08M33");
+		// everything (in particular the server connection)
-} catch (IOException e) {
+		close();
-throw new SQLException(e.getMessage(), "08000");
+	}
-}
-}
+	/**
+	 * Sets the maximum period a Connection or objects created from the
-/**
+	 * Connection will wait for the database to reply to any one
-* Adds a warning to the pile of warnings this Connection object has. If there were no warnings (or clearWarnings
+	 * request. If any request remains unanswered, the waiting method
-* was called) this warning will be the first, otherwise this warning will get appended to the current warning.
+	 * will return with a SQLException, and the Connection or objects
-*
+	 * created from the Connection will be marked as closed. Any
-* @param reason the warning message
+	 * subsequent use of the objects, with the exception of the close,
-*/
+	 * isClosed or Connection.isValid methods, will result in a
-protected void addWarning(String reason, String sqlstate) {
+	 * SQLException.
-if (warnings == null) {
+	 *
-warnings = new SQLWarning(reason, sqlstate);
+	 * @param executor The Executor implementation which will be used by setNetworkTimeout
-} else {
+	 * @param millis The time in milliseconds to wait for the database operation to complete
-warnings.setNextWarning(new SQLWarning(reason, sqlstate));
+	 * @throws SQLException if a database access error occurs, this method is called on a closed connection, the
-}
+	 * executor is null, or the value specified for seconds is less than 0.
-}
+	 */
+	@Override
-/**
+	public void setNetworkTimeout(Executor executor, int millis) throws SQLException {
-* A list of Response objects. Responses are added to this list. Methods of this class are not synchronized. This is
+		if (closed)
-* left as responsibility to the caller to prevent concurrent access.
+			throw new SQLException("Cannot call on closed Connection", "M1M20");
-*/
+		if (executor == null)
-public class ResponseList {
+			throw new SQLException("executor is null", "M1M05");
+		if (millis < 0)
-/** The cache size (number of rows in a DataBlockResponse object) */
+			throw new SQLException("milliseconds is less than zero", "M1M05");
-private final int cachesize;
-/** The maximum number of results for this query */
+		try {
-private final int maxrows;
+			this.setSoTimeout(millis);
-/** The ResultSet type to produce */
+		} catch (SocketException e) {
-private final int rstype;
+			throw new SQLNonTransientConnectionException(e.getMessage(), "08000");
-/** The ResultSet concurrency to produce */
+		}
-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 */
+	 * Retrieves the number of milliseconds the driver will wait for a
-private final List<IResponse> responses = new ArrayList<>();
+	 * database request to complete. If the limit is exceeded, a
-/** A map of ResultSetResponses, used for additional DataBlockResponse mapping */
+	 * SQLException is thrown.
-private Map<Integer, ResultSetResponse> rsresponses;
+	 *
-/** The current header returned by getNextResponse() */
+	 * @return the current timeout limit in milliseconds; zero means
-private int curResponse = -1;
+	 *         there is no limit
+	 * @throws SQLException if a database access error occurs or
-/**
+	 *         this method is called on a closed Connection
-* Main constructor. The query argument can either be a String or List.  An SQLException is thrown if another
+	 * @since 1.7
-* object instance is supplied.
+	 */
-*
+	@Override
-* @param cachesize overall cachesize to use
+	public int getNetworkTimeout() throws SQLException {
-* @param maxrows maximum number of rows to allow in the set
+		if (closed)
-* @param rstype the type of result sets to produce
+			throw new SQLException("Cannot call on closed Connection", "M1M20");
-* @param rsconcur the concurrency of result sets to produce
-*/
+		try {
-ResponseList(int cachesize, int maxrows, int rstype, int rsconcur) {
+			return this.getSoTimeout();
-this.cachesize = cachesize;
+		} catch (SocketException e) {
-this.maxrows = maxrows;
+			throw new SQLNonTransientConnectionException(e.getMessage(), "08000");
-this.rstype = rstype;
+		}
-this.rsconcur = rsconcur;
+	}
-this.seqnr = SeqCounter++;
-}
+	//== end methods of interface Connection
-public int getCachesize() {
+	/**
-return cachesize;
+	 * Returns whether the BLOB type should be mapped to BINARY type.
-}
+	 */
+	public boolean getBlobAsBinary() {
-public int getRstype() {
+		return blobIsBinary;
-return rstype;
+	}
-}
+	/**
-public int getRsconcur() {
+	 * Returns whether the CLOB type should be mapped to LONGVARCHAR type.
-return rsconcur;
+	 */
-}
+	public boolean getClobAsLongChar() {
+		return clobIsLongChar;
-public int getMaxrows() {
+	}
-return maxrows;
-}
+	/**
+	 * Sends the given string to MonetDB as special transaction command.
-/**
+	 * All possible returned information is discarded.
-* Retrieves the next available response, or null if there are no more responses.
+	 * Encountered errors are reported.
-*
+	 *
-* @return the next Response available or null
+	 * @param command the exact string to send to MonetDB
-*/
+	 * @throws SQLException if an IO exception or a database error occurs
-IResponse getNextResponse() throws SQLException {
+	 */
-if (rstype == ResultSet.TYPE_FORWARD_ONLY) {
+	private void sendTransactionCommand(String command) throws SQLException {
-// free resources if we're running forward only
+		// create a container for the result
-if (curResponse >= 0 && curResponse < responses.size()) {
+		ResponseList l = new ResponseList(0, 0, ResultSet.FETCH_FORWARD, ResultSet.CONCUR_READ_ONLY);
-IResponse tmp = responses.get(curResponse);
+		// send the appropriate query string to the database
-if (tmp != null) {
+		try {
-tmp.close();
+			l.processQuery(command);
-}
+		} finally {
-responses.set(curResponse, null);
+			l.close();
-}
+		}
-}
+	}
-curResponse++;
-if (curResponse >= responses.size()) {
+	/**
-// ResponseList is obviously completed so, there are no more responses
+	 * Sends the given string to MonetDB as regular statement, making sure there is a prompt after the command is sent.
-return null;
+	 * All possible returned information is discarded. Encountered errors are reported.
-} else {
+	 *
-// return this response
+	 * @param command the exact string to send to MonetDB
-return responses.get(curResponse);
+	 * @throws SQLException if an IO exception or a database error occurs
-}
+	 */
-}
+	void sendIndependentCommand(String command) throws SQLException {
+		try {
-/**
+			protocol.writeNextQuery(language.getQueryTemplateIndex(0), command, language.getQueryTemplateIndex(1));
-* Closes the Response at index i, if not null.
+			protocol.waitUntilPrompt();
-*
+			int csrh = protocol.getCurrentServerResponse();
-* @param i the index position of the header to close
+			if (csrh == ServerResponses.ERROR) {
-*/
+				String error = protocol.getRemainingStringLine(0);
-void closeResponse(int i) {
+				throw new SQLException(error.substring(6), error.substring(0, 5));
-if (i < 0 || i >= responses.size()) return;
+			}
-IResponse tmp = responses.set(i, null);
+		} catch (SocketTimeoutException e) {
-if (tmp != null)
+			close(); // JDBC 4.1 semantics: abort()
-tmp.close();
+			throw new SQLNonTransientConnectionException("connection timed out", "08M33");
-}
+		} catch (IOException e) {
+			throw new SQLNonTransientConnectionException(e.getMessage(), "08000");
-/**
+		}
-* Closes the current response.
+	}
-*/
-void closeCurrentResponse() {
+	/**
-closeResponse(curResponse);
+	 * Adds a warning to the pile of warnings this Connection object has. If there were no warnings (or clearWarnings
-}
+	 * was called) this warning will be the first, otherwise this warning will get appended to the current warning.
+	 *
-/**
+	 * @param reason the warning message
-* Closes the current and previous responses.
+	 */
-*/
+	void addWarning(String reason, String sqlstate) {
-void closeCurOldResponses() {
+		if (warnings == null) {
-for (int i = curResponse; i >= 0; i--) {
+			warnings = new SQLWarning(reason, sqlstate);
-closeResponse(i);
+		} else {
-}
+			warnings.setNextWarning(new SQLWarning(reason, sqlstate));
-}
+		}
+	}
-/**
-* Closes this ResponseList by closing all the Responses in this ResponseList.
+	/**
-*/
+	 * A list of Response objects. Responses are added to this list. Methods of this class are not synchronized. This is
-public void close() {
+	 * left as responsibility to the caller to prevent concurrent access.
-for (int i = 0; i < responses.size(); i++) {
+	 */
-closeResponse(i);
+	public class ResponseList {
-}
-}
+		/** The cache size (number of rows in a DataBlockResponse object) */
+		private final int cachesize;
-/**
+		/** The maximum number of results for this query */
-* Returns whether this ResponseList has still unclosed Responses.
+		private final int maxrows;
-*/
+		/** The ResultSet type to produce */
-boolean hasUnclosedResponses() {
+		private final int rstype;
-for (IResponse r : responses) {
+		/** The ResultSet concurrency to produce */
-if (r != null)
+		private final int rsconcur;
-return true;
+		/** The sequence number of this ResponseList */
-}
+		private final int seqnr;
-return false;
+		/** A list of the Responses associated with the query, in the right order */
-}
+		private final List<IResponse> responses = new ArrayList<>();
+		/** A map of ResultSetResponses, used for additional DataBlockResponse mapping */
-/**
+		private Map<Integer, ResultSetResponse> rsresponses;
-* Executes the query contained in this ResponseList, and stores the Responses resulting from this query in this
+		/** The current header returned by getNextResponse() */
-* ResponseList.
+		private int curResponse = -1;
-*
-* @throws SQLException if a database error occurs
+		/**
-*/
+		 * Main constructor. The query argument can either be a String or List.  An SQLException is thrown if another
-void processQuery(String query) throws SQLException {
+		 * object instance is supplied.
-this.executeQuery(language.getQueryTemplates(), query);
+		 *
-}
+		 * @param cachesize overall cachesize to use
+		 * @param maxrows maximum number of rows to allow in the set
-/**
+		 * @param rstype the type of result sets to produce
-* Internal executor of queries.
+		 * @param rsconcur the concurrency of result sets to produce
-*
+		 */
-* @param templ the template to fill in
+		ResponseList(int cachesize, int maxrows, int rstype, int rsconcur) {
-* @param query the query to execute
+			this.cachesize = cachesize;
-* @throws SQLException if a database error occurs
+			this.maxrows = maxrows;
-*/
+			this.rstype = rstype;
-@SuppressWarnings("fallthrough")
+			this.rsconcur = rsconcur;
-public void executeQuery(String[] templ, String query) throws SQLException {
+			this.seqnr = SeqCounter++;
-String error = null;
+		}
-try {
+		public int getCachesize() {
-// make sure we're ready to send query; read data till we have the prompt it is possible (and most
+			return cachesize;
-// likely) that we already have the prompt and do not have to skip any lines. Ignore errors from
+		}
-// previous result sets.
-protocol.waitUntilPrompt();
+		public int getRstype() {
+			return rstype;
-// {{{ set reply size
+		}
-/*
-* Change the reply size of the server.  If the given value is the same as the current value known
+		public int getRsconcur() {
-* to use, then ignore this call.  If it is set to 0 we get a prompt after the server sent it's
+			return rsconcur;
-* header.
+		}
-*
-* 2017: For now, in the embedded connection, the value set cachesize will be always the default one.
+		public int getMaxrows() {
-*/
+			return maxrows;
-int size = (cachesize != 0 && !isEmbedded) ? cachesize : MonetConnection.this.getDefFetchsize();
+		}
-size = maxrows != 0 ? Math.min(maxrows, size) : size;
-// don't do work if it's not needed
+		/**
-if (!isEmbedded && language.getRepresentation().equals("sql") && size != curReplySize &&
+		 * Retrieves the next available response, or null if there are no more responses.
-!Arrays.deepEquals(templ, language.getCommandTemplates())) {
+		 *
-sendControlCommand(ControlCommands.REPLY_SIZE, size);
+		 * @return the next Response available or null
-// store the reply size after a successful change
+		 */
-curReplySize = size;
+		IResponse getNextResponse() throws SQLException {
-}
+			if (rstype == ResultSet.TYPE_FORWARD_ONLY) {
-// }}} set reply size
+				// free resources if we're running forward only
+				if (curResponse >= 0 && curResponse < responses.size()) {
-// If the query is larger than the TCP buffer size, use a special send thread to avoid deadlock with
+					IResponse tmp = responses.get(curResponse);
-// the server due to blocking behaviour when the buffer is full. Because the server will be writing
+					if (tmp != null) {
-// back results to us, it will eventually block as well when its TCP buffer gets full, as we are
+						tmp.close();
-// blocking an not consuming from it. The result is a state where both client and server want to
+					}
-// write, but block.
+					responses.set(curResponse, null);
-if (query.length() > getBlockSize()) {
+				}
-// get a reference to the send thread
+			}
-if (senderThread == null) {
+			curResponse++;
-senderThread = new SenderThread(protocol);
+			if (curResponse >= responses.size()) {
-}
+				// ResponseList is obviously completed so, there are no more responses
-// tell it to do some work!
+				return null;
-senderThread.runQuery(templ, query);
+			} else {
-} else {
+				// return this response
-// this is a simple call, which is a lot cheaper and will always succeed for small queries.
+				return responses.get(curResponse);
-protocol.writeNextQuery((templ[0] == null) ? "" : templ[0], query,
+			}
-(templ[1] == null) ? "" : templ[1]);
+		}
-}
+		/**
-// go for new results
+		 * Closes the Response at index i, if not null.
-protocol.fetchNextResponseData();
+		 *
-int nextResponse = protocol.getCurrentServerResponse();
+		 * @param i the index position of the header to close
-IResponse res = null;
+		 */
-while (nextResponse != ServerResponses.PROMPT) {
+		void closeResponse(int i) {
-// each response should start with a start of header (or error)
+			if (i < 0 || i >= responses.size()) return;
-switch (nextResponse) {
+			IResponse tmp = responses.set(i, null);
-case ServerResponses.SOHEADER:
+			if (tmp != null)
-// make the response object, and fill it
+				tmp.close();
-int nextStartHeader = protocol.getNextStarterHeader();
+		}
-try {
-switch (nextStartHeader) {
+		/**
-case StarterHeaders.Q_PARSE:
+		 * Closes the current response.
-throw new ProtocolException("Q_PARSE header not allowed here");
+		 */
-case StarterHeaders.Q_TABLE:
+		void closeCurrentResponse() {
-case StarterHeaders.Q_PREPARE: {
+			closeResponse(curResponse);
-res = protocol.getNextResultSetResponse(MonetConnection.this,
+		}
-ResponseList.this, this.seqnr, this.maxrows);
-ResultSetResponse rsreponse = (ResultSetResponse) res;
+		/**
-if (rsresponses == null) {
+		 * Closes the current and previous responses.
-rsresponses = new HashMap<>();
+		 */
-}
+		void closeCurOldResponses() {
-rsresponses.put(rsreponse.getId(), rsreponse);
+			for (int i = curResponse; i >= 0; i--) {
-}
+				closeResponse(i);
-break;
+			}
-case StarterHeaders.Q_UPDATE:
+		}
-res = protocol.getNextUpdateResponse();
-break;
+		/**
-case StarterHeaders.Q_SCHEMA:
+		 * Closes this ResponseList by closing all the Responses in this ResponseList.
-res = protocol.getNextSchemaResponse();
+		 */
-break;
+		public void close() {
-case StarterHeaders.Q_TRANS:
+			for (int i = 0; i < responses.size(); i++) {
-res = protocol.getNextAutoCommitResponse();
+				closeResponse(i);
-boolean isAutoCommit = ((AutoCommitResponse) res).isAutocommit();
+			}
+		}
-if (MonetConnection.this.getAutoCommit() && isAutoCommit) {
-MonetConnection.this.addWarning("Server enabled auto commit mode " +
+		/**
-"while local state already was auto commit.", "01M11");
+		 * Returns whether this ResponseList has still unclosed Responses.
-}
+		 */
-MonetConnection.this.autoCommit = isAutoCommit;
+		boolean hasUnclosedResponses() {
-break;
+			for (IResponse r : responses) {
-case StarterHeaders.Q_BLOCK: {
+				if (r != null)
-AbstractDataBlockResponse next = protocol.getNextDatablockResponse(rsresponses);
+					return true;
-if (next == null) {
+			}
-error = "M0M12!No ResultSetResponse for a DataBlock found";
+			return false;
-break;
+		}
-}
-res = next;
+		/**
-}
+		 * Executes the query contained in this ResponseList, and stores the Responses resulting from this query in this
-break;
+		 * ResponseList.
-}
+		 *
-} catch (ProtocolException e) {
+		 * @throws SQLException if a database error occurs
-error = "M0M10!error while parsing start of header:\n" + e.getMessage() + " found: '"
+		 */
-+ protocol.getRemainingStringLine(0).charAt(e.getErrorOffset()) + "'" +
+		void processQuery(String query) throws SQLException {
-" in: \"" + protocol.getRemainingStringLine(0) + "\"" + " at pos: "
+			this.executeQuery(language.getQueryTemplates(), query);
-+ e.getErrorOffset();
+		}
-// flush all the rest
-protocol.waitUntilPrompt();
+		/**
-nextResponse = protocol.getCurrentServerResponse();
+		 * Internal executor of queries.
-break;
+		 *
-}
+		 * @param templ the template to fill in
+		 * @param query the query to execute
-// immediately handle errors after parsing the header (res may be null)
+		 * @throws SQLException if a database error occurs
-if (error != null) {
+		 */
-protocol.waitUntilPrompt();
+		@SuppressWarnings("fallthrough")
-nextResponse = protocol.getCurrentServerResponse();
+		public void executeQuery(String[] templ, String query) throws SQLException {
-break;
+			String error = null;
-}
+			try {
-// here we have a res object, which we can start filling
+				// make sure we're ready to send query; read data till we have the prompt it is possible (and most
-if (res instanceof IIncompleteResponse) {
+				// likely) that we already have the prompt and do not have to skip any lines. Ignore errors from
-IIncompleteResponse iter = (IIncompleteResponse) res;
+				// previous result sets.
-while (iter.wantsMore()) {
+				protocol.waitUntilPrompt();
-try {
-protocol.fetchNextResponseData();
+				// {{{ set reply size
-iter.addLines(protocol);
+				/*
-} catch (ProtocolException ex) {
+				 * Change the reply size of the server.  If the given value is the same as the current value known
-// right, some protocol violation, skip the rest of the result
+				 * to use, then ignore this call.  If it is set to 0 we get a prompt after the server sent it's
-error = "M0M10!" + ex.getMessage();
+				 * header.
-protocol.waitUntilPrompt();
+				 *
-nextResponse = protocol.getCurrentServerResponse();
+				 * 2017: For now, in the embedded connection, the value set cachesize will be always the default one.
-break;
+				 */
-}
+				int size = (cachesize != 0 && !isEmbedded) ? cachesize : MonetConnection.this.getDefFetchsize();
-}
+				size = maxrows != 0 ? Math.min(maxrows, size) : size;
-}
+				// don't do work if it's not needed
+				if (!isEmbedded && language.getRepresentation().equals("sql") && size != curReplySize &&
-if (error != null) {
+						!Arrays.deepEquals(templ, language.getCommandTemplates())) {
-break;
+					sendControlCommand(ControlCommands.REPLY_SIZE, size);
-}
+					// store the reply size after a successful change
+					curReplySize = size;
-// it is of no use to store DataBlockResponses, you never want to retrieve them directly
+				}
-// anyway
+				// }}} set reply size
-if (!(res instanceof AbstractDataBlockResponse)) {
-responses.add(res);
+				// If the query is larger than the TCP buffer size, use a special send thread to avoid deadlock with
-}
+				// the server due to blocking behaviour when the buffer is full. Because the server will be writing
-// read the next line (can be prompt, new result, error, etc.) before we start the loop over
+				// back results to us, it will eventually block as well when its TCP buffer gets full, as we are
-protocol.fetchNextResponseData();
+				// blocking an not consuming from it. The result is a state where both client and server want to
-nextResponse = protocol.getCurrentServerResponse();
+				// write, but block.
-break;
+				if (query.length() > getBlockSize()) {
-case ServerResponses.INFO:
+					// get a reference to the send thread
-addWarning(protocol.getRemainingStringLine(0), "01000");
+					if (senderThread == null) {
-// read the next line (can be prompt, new result, error, etc.) before we start the loop over
+						senderThread = new SenderThread(protocol);
-protocol.fetchNextResponseData();
+					}
-nextResponse = protocol.getCurrentServerResponse();
+					// tell it to do some work!
-break;
+					senderThread.runQuery(templ, query);
-case ServerResponses.ERROR:
+				} else {
-// read everything till the prompt (should be error) we don't know if we ignore some
+					// this is a simple call, which is a lot cheaper and will always succeed for small queries.
-// garbage here... but the log should reveal that
+					protocol.writeNextQuery((templ[0] == null) ? "" : templ[0], query,
-error = protocol.getRemainingStringLine(0);
+							(templ[1] == null) ? "" : templ[1]);
-protocol.waitUntilPrompt();
+				}
-nextResponse = protocol.getCurrentServerResponse();
-break;
+				// go for new results
-default:
+				protocol.fetchNextResponseData();
-throw new SQLException("Protocol violation, unexpected line!", "M0M10");
+				int nextResponse = protocol.getCurrentServerResponse();
-}
+				IResponse res = null;
-}
+				while (nextResponse != ServerResponses.PROMPT) {
+					// each response should start with a start of header (or error)
-// if we used the senderThread, make sure it has finished
+					switch (nextResponse) {
-if (senderThread != null) {
+						case ServerResponses.SOHEADER:
-String tmp = senderThread.getErrors();
+							// make the response object, and fill it
-if (tmp != null) {
+							int nextStartHeader = protocol.getNextStarterHeader();
-if (error == null) {
+							try {
-error = "08000!" + tmp;
+								switch (nextStartHeader) {
-} else {
+									case StarterHeaders.Q_PARSE:
-error += "\n08000!" + tmp;
+										throw new ProtocolException("Q_PARSE header not allowed here");
-}
+									case StarterHeaders.Q_TABLE:
-}
+									case StarterHeaders.Q_PREPARE: {
-}
+										res = protocol.getNextResultSetResponse(MonetConnection.this,
-if (error != null) {
+												ResponseList.this, this.seqnr, this.maxrows);
-SQLException ret = null;
+										ResultSetResponse rsreponse = (ResultSetResponse) res;
-String[] errorsList = error.split("\n");
+										if (rsresponses == null) {
-for (String singleError : errorsList) {
+											rsresponses = new HashMap<>();
-String reason = isEmbedded() ? singleError : singleError.substring(6);
+										}
-String sqlState = isEmbedded() ? "M0M10" : singleError.substring(0, 5);
+										rsresponses.put(rsreponse.getId(), rsreponse);
-if (ret == null) {
+									}
-ret = new SQLException(reason, sqlState);
+									break;
-} else {
+									case StarterHeaders.Q_UPDATE:
-ret.setNextException(new SQLException(reason, sqlState));
+										res = protocol.getNextUpdateResponse();
-}
+										break;
-}
+									case StarterHeaders.Q_SCHEMA:
-throw ret;
+										res = protocol.getNextSchemaResponse();
-}
+										break;
-} catch (SocketTimeoutException e) {
+									case StarterHeaders.Q_TRANS:
-this.close(); // JDBC 4.1 semantics, abort()
+										res = protocol.getNextAutoCommitResponse();
-throw new SQLException("connection timed out", "08M33");
+										boolean isAutoCommit = ((AutoCommitResponse) res).isAutocommit();
-} catch (IOException e) {
-closed = true;
+										if (MonetConnection.this.getAutoCommit() && isAutoCommit) {
-throw new SQLException(e.getMessage() + " (mserver still alive?)", "08000");
+											MonetConnection.this.addWarning("Server enabled auto commit mode " +
-}
+													"while local state already was auto commit.", "01M11");
-}
+										}
-}
+										MonetConnection.this.autoCommit = isAutoCommit;
+										break;
+									case StarterHeaders.Q_BLOCK: {
+										AbstractDataBlockResponse next = protocol.getNextDatablockResponse(rsresponses);
+										if (next == null) {
+											error = "M0M12!No ResultSetResponse for a DataBlock found";
+											break;
+										}
+										res = next;
+									}
+									break;
+								}
+							} catch (ProtocolException e) {
+								error = "M0M10!error while parsing start of header:\n" + e.getMessage() + " found: '"
+										+ protocol.getRemainingStringLine(0).charAt(e.getErrorOffset()) + "'" +
+										" in: \"" + protocol.getRemainingStringLine(0) + "\"" + " at pos: "
+										+ e.getErrorOffset();
+								// flush all the rest
+								protocol.waitUntilPrompt();
+								nextResponse = protocol.getCurrentServerResponse();
+								break;
+							}
+							// immediately handle errors after parsing the header (res may be null)
+							if (error != null) {
+								protocol.waitUntilPrompt();
+								nextResponse = protocol.getCurrentServerResponse();
+								break;
+							}
+							// here we have a res object, which we can start filling
+							if (res instanceof IIncompleteResponse) {
+								IIncompleteResponse iter = (IIncompleteResponse) res;
+								while (iter.wantsMore()) {
+									try {
+										protocol.fetchNextResponseData();
+										iter.addLines(protocol);
+									} catch (ProtocolException ex) {
+										// right, some protocol violation, skip the rest of the result
+										error = "M0M10!" + ex.getMessage();
+										protocol.waitUntilPrompt();
+										nextResponse = protocol.getCurrentServerResponse();
+										break;
+									}
+								}
+							}
+							if (error != null) {
+								break;
+							}
+							// it is of no use to store DataBlockResponses, you never want to retrieve them directly
+							// anyway
+							if (!(res instanceof AbstractDataBlockResponse)) {
+								responses.add(res);
+							}
+							// read the next line (can be prompt, new result, error, etc.) before we start the loop over
+							protocol.fetchNextResponseData();
+							nextResponse = protocol.getCurrentServerResponse();
+							break;
+						case ServerResponses.INFO:
+							addWarning(protocol.getRemainingStringLine(0), "01000");
+							// read the next line (can be prompt, new result, error, etc.) before we start the loop over
+							protocol.fetchNextResponseData();
+							nextResponse = protocol.getCurrentServerResponse();
+							break;
+						case ServerResponses.ERROR:
+							// read everything till the prompt (should be error) we don't know if we ignore some
+							// garbage here... but the log should reveal that
+							error = protocol.getRemainingStringLine(0);
+							protocol.waitUntilPrompt();
+							nextResponse = protocol.getCurrentServerResponse();
+							break;
+						default:
+							throw new SQLException("Protocol violation, unexpected line!", "M0M10");
+					}
+				}
+				// if we used the senderThread, make sure it has finished
+				if (senderThread != null) {
+					String tmp = senderThread.getErrors();
+					if (tmp != null) {
+						if (error == null) {
+							error = "08000!" + tmp;
+						} else {
+							error += "\n08000!" + tmp;
+						}
+					}
+				}
+				if (error != null) {
+					SQLException ret = null;
+					String[] errorsList = error.split("\n");
+					for (String singleError : errorsList) {
+						SQLException newErr;
+						String reason = isEmbedded() ? singleError : singleError.substring(6);
+						String sqlState = isEmbedded() ? "M0M10" : singleError.substring(0, 5);
+						if (singleError.length() >= 6) {
+							newErr = new SQLException(reason, sqlState);
+						} else {
+							newErr = new SQLNonTransientConnectionException(singleError, "08000");
+						}
+						if (ret == null) {
+							ret = newErr;
+						} else {
+							ret.setNextException(newErr);
+						}
+					}
+					throw ret;
+				}
+			} catch (SocketTimeoutException e) {
+				this.close(); // JDBC 4.1 semantics, abort()
+				throw new SQLNonTransientConnectionException("connection timed out", "08M33");
+			} catch (IOException e) {
+				closed = true;
+				throw new SQLNonTransientConnectionException(e.getMessage() + " (mserver5 still alive?)", "08006");
+			}
+		}
+	}
 }

Mercurial > hg > monetdb-java

comparison src/main/java/nl/cwi/monetdb/jdbc/MonetConnection.java @ 172:60063c67f9e7 embedded