statement.java

SearchPathServer

	 * @return the current query timeout limit in seconds; 0 = unlimited
	 * @exception java.sql.SQLException if a database access error occurs
	 */

	public  int getQueryTimeout() throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = new Object[0];
			Debug.methodCall(this, "getQueryTimeout", Args);
		}

		return _timeout;
	}

	/**
	 * Sets the queryTimeout limit
	 *
	 * @param seconds - the new query timeout limit in seconds
	 * @exception java.sql.SQLException if a database access error occurs
	 */

	public  void setQueryTimeout(int seconds) throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = { new Integer(seconds)};
			Debug.methodCall(this, "setQueryTimeout", Args);
		}

		_timeout = seconds;
	}

	/**
	 * Cancel can be used by one thread to cancel a statement that
	 * is being executed by another thread.  However this driver
	 * is synchronous, so this really has no meaning - we
	 * define it as a no-op (i.e. you can't cancel, but there is no
	 * error if you try.)
	 *
	 * @exception java.sql.SQLException only because thats the spec.
	 */

	public  void cancel() throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = new Object[0];
			Debug.methodCall(this, "cancel", Args);
		}

		// No-op
	}

	/**
	 * The first warning reported by calls on this Statement is
	 * returned.  A Statement's execute methods clear its java.sql.SQLWarning
	 * chain.  Subsequent Statement warnings will be chained to this
	 * java.sql.SQLWarning.
	 *
	 * <p>The Warning chain is automatically cleared each time a statement
	 * is (re)executed.
	 *
	 * <p><B>Note:</B>  If you are processing a ResultSet then any warnings
	 * associated with ResultSet reads will be chained on the ResultSet
	 * object.
	 *
	 * @return the first java.sql.SQLWarning on null
	 * @exception java.sql.SQLException if a database access error occurs
	 */

	public  java.sql.SQLWarning getWarnings() throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = new Object[0];
			Debug.methodCall(this, "getWarnings", Args);
		}

		return _warnings;
	}

	/**
	 * After this call, getWarnings returns null until a new warning
	 * is reported for this Statement.
	 *
	 * @exception java.sql.SQLException if a database access error occurs (why?)
	 */

	public  void clearWarnings() throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = new Object[0];
			Debug.methodCall(this, "clearWarnings", Args);
		}

		_warnings = null;
	}

	/**
	 * setCursorName defines the SQL cursor name that will be used by
	 * subsequent execute methods.  This name can then be used in SQL
	 * positioned update/delete statements to identify the current row
	 * in the ResultSet generated by this statement.  If a database
	 * doesn't support positioned update/delete, this method is a
	 * no-op.
	 *
	 * <p><b>Note:</b> This MySQL driver does not support cursors.
	 *
	 *
	 * @param name the new cursor name
	 * @exception java.sql.SQLException if a database access error occurs
	 */

	public  void setCursorName(String name) throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = { name };
			Debug.methodCall(this, "setCursorName", Args);
		}

		// No-op
	}

	/**
	 * Execute a SQL statement that may return multiple results. We
	 * don't have to worry about this since we do not support multiple
	 * ResultSets.   You can use getResultSet or getUpdateCount to
	 * retrieve the result.
	 *
	 * @param sql any SQL statement
	 * @return true if the next result is a ResulSet, false if it is
	 *      an update count or there are no more results
	 * @exception java.sql.SQLException if a database access error occurs
	 */

	public  boolean execute(String sql) throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = { sql };
			Debug.methodCall(this, "execute", Args);
		}

		if (_escapeProcessing) {
			sql = _escaper.escapeSQL(sql);
		}


		if (_results != null) {
			_results.close();
		}

		ResultSet rs = null;

		// If there isn't a limit clause in the SQL
		// then limit the number of rows to return in 
		// an efficient manner. Only do this if
		// setMaxRows() hasn't been used on any Statements
		// generated from the current Connection (saves
		// a query, and network traffic).

		 synchronized (_conn.getMutex()) {
			String oldCatalog = null;

			if (!_conn.getCatalog().equals(_catalog)) {
				oldCatalog = _conn.getCatalog();
				_conn.setCatalog(_catalog);
			}

			// 
			// Only apply max_rows to selects
			//

			if (_conn.useMaxRows()) {

				char firstChar = Character.toUpperCase(sql.charAt(0));

				if (firstChar == 'S') {
					if (sql.toUpperCase().indexOf("LIMIT") != -1) {
						rs = _conn.execSQL(sql, _maxRows);
					}
					else {
						if (_maxRows <= 0) {
							_conn.execSQL("SET OPTION SQL_SELECT_LIMIT=DEFAULT", -1);
						}
						else {
							_conn.execSQL("SET OPTION SQL_SELECT_LIMIT=" + _maxRows, -1);
						}

					}
				}
				else {
					_conn.execSQL("SET OPTION SQL_SELECT_LIMIT=DEFAULT", -1);
				}

				// Finally, execute the query
				rs = _conn.execSQL(sql, -1);
			}
			else {
				rs = _conn.execSQL(sql, -1);
			}

			if (oldCatalog != null) {
				_conn.setCatalog(oldCatalog);
			}
		}

		_lastInsertId = rs.getUpdateID();

		if (rs != null) {
			_results = rs;

		}

		rs.setConnection(_conn);
		rs.setResultSetType(_resultSetType);
		rs.setResultSetConcurrency(_resultSetConcurrency);

		return (rs != null && rs.reallyResult());
	}

	/**
	 * getResultSet returns the current result as a ResultSet.  It
	 * should only be called once per result.
	 *
	 * @return the current result set; null if there are no more
	 * @exception java.sql.SQLException if a database access error occurs (why?)
	 */

	public  java.sql.ResultSet getResultSet() throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = new Object[0];
			Debug.methodCall(this, "getResultSet", Args);
		}

		return (_results != null && _results.reallyResult())
			? (java.sql.ResultSet) _results
			: null;
	}

	/**
	 * getUpdateCount returns the current result as an update count,
	 * if the result is a ResultSet or there are no more results, -1
	 * is returned.  It should only be called once per result.
	 *
	 * @return the current result as an update count.
	 * @exception java.sql.SQLException if a database access error occurs
	 */

	public  int getUpdateCount() throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = new Object[0];
			Debug.methodCall(this, "getUpdateCount", Args);
		}

		if (_results == null) {
			return -1;
		}
		if (_results.reallyResult()) {
			return -1;
		}

		int truncated_updateCount = 0;

		if (_results.getUpdateCount() > Integer.MAX_VALUE) {
			truncated_updateCount = Integer.MAX_VALUE;
		}
		else {
			truncated_updateCount = (int) _results.getUpdateCount();
		}

		return truncated_updateCount;
	}

	/**
	 * getLongUpdateCount returns the current result as an update count,
	 * if the result is a ResultSet or there are no more results, -1
	 * is returned.  It should only be called once per result.
	 *
	 * <p>
	 * This method returns longs as MySQL server versions newer than 
	 * 3.22.4 return 64-bit values for update counts
	 *
	 * @return the current result as an update count.
	 * @exception java.sql.SQLException if a database access error occurs
	 */

	public  long getLongUpdateCount() {
		if (Driver.trace) {
			Object[] Args = new Object[0];
			Debug.methodCall(this, "getLongUpdateCount", Args);
		}

		if (_results == null) {
			return -1;
		}

		if (_results.reallyResult()) {
			return -1;
		}

		return _updateCount;
	}

	/**
	 * getLastInsertID returns the value of the auto_incremented key
	 * after an executeQuery() or excute() call.
	 *
	 * <p>
	 * This gets around the un-threadsafe behavior of
	 * "select LAST_INSERT_ID()" which is tied to the Connection
	 * that created this Statement, and therefore could have had
	 * many INSERTS performed before one gets a chance to call
	 * "select LAST_INSERT_ID()".
	 *
	 * @return the last update ID.
	 */

	public  long getLastInsertID() {
		if (Driver.trace) {
			Object[] Args = new Object[0];
			Debug.methodCall(this, "getLastInsertID", Args);
		}

		return _lastInsertId;
	}

	/**
	 * getMoreResults moves to a Statement's next result.  If it returns
	 * true, this result is a ResulSet.
	 *
	 * @return true if the next ResultSet is valid
	 * @exception java.sql.SQLException if a database access error occurs
	 */

	public  boolean getMoreResults() throws java.sql.SQLException {
		if (Driver.trace) {
			Object[] Args = new Object[0];
			Debug.methodCall(this, "getMoreResults", Args);
		}
		if (_results != null) {
			_results.close();
		}

		_results = _nextResults;
		_nextResults = null;

		return (_results != null && _results.reallyResult()) ? true : false;
	}

	//--------------------------JDBC 2.0-----------------------------

	/**
	 * JDBC 2.0
	 *
	 * Give a hint as to the direction in which the rows in a result set
	 * will be processed. The hint applies only to result sets created 
	 * using this Statement object.  The default value is 
	 * ResultSet.FETCH_FORWARD.
	 *
	 * @param direction the initial direction for processing rows
	 * @exception SQLException if a database-access error occurs or direction
	 * is not one of ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE, or
	 * ResultSet.FETCH_UNKNOWN
	 */

	public  void setFetchDirection(int direction) throws SQLException {

	}

	/**
	 * JDBC 2.0
	 *
	 * Determine the fetch direction.
	 *
	 * @return the default fetch direction
	 * @exception SQLException if a database-access error occurs
	 */

	public  int getFetchDirection() throws SQLException {
		return 0;
	}

	/**
	 * JDBC 2.0
	 *
	 * Give the JDBC driver a hint as to the number of rows that should 
	 * be fetched from the database when more rows are needed.  The number 
	 * of rows specified only affects result sets created using this 
	 * statement. If the value specified is zero, then the hint is ignored.
	 * The default value is zero.
	 *
	 * @param rows the number of rows to fetch
	 * @exception SQLException if a database-access error occurs, or the
	 * condition 0 <= rows <= this.getMaxRows() is not satisfied.
	 */

	public  void setFetchSize(int rows) throws SQLException {
	}

	/**
	 * JDBC 2.0
	 *
	 * Determine the default fetch size.
	 */

	public  int getFetchSize() throws SQLException {
		return 0;
	}

	/**
	 * JDBC 2.0
	 *
	 * Determine the result set concurrency.
	 */

	public  int getResultSetConcurrency() throws SQLException {

		return _resultSetConcurrency;
	}

	/**
	 * JDBC 2.0
	 *
	 * Determine the result set type.
	 */

	public int getResultSetType() throws SQLException {
		return _resultSetType;
	}

	public  void addBatch(String sql) throws SQLException {

		if (_batchedArgs == null) {

			_batchedArgs = new Vector();

		}

		if (sql != null) {
			_batchedArgs.addElement(sql);
		}

	}

	/**
	 * JDBC 2.0
	 *
	 * Make the set of commands in the current batch empty.
	 * This method is optional.
	 *
	 * @exception SQLException if a database-access error occurs, or the
	 * driver does not support batch statements
	 */

	public  void clearBatch() throws SQLException {
		if (_batchedArgs != null) {
			_batchedArgs.setSize(0);
		}
	}

	/**
	 * JDBC 2.0
	 * 
	 * Return the Connection that produced the Statement.
	 */

	public java.sql.Connection getConnection() throws SQLException {
		return (java.sql.Connection) _conn;
	}
}