statement.java

关于jdbc对mysql的官方驱动程序

	_Conn.maxRowsChanged();
    }

    /**
     * If escape scanning is on (the default), the driver will do escape
     * substitution before sending the SQL to the database.
     *
     * @param enable true to enable; false to disable
     * @exception java.sql.SQLException if a database access error occurs
     */

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

	_escapeProcessing = enable;
    } 

    /**
     * The queryTimeout limit is the number of seconds the driver
     * will wait for a Statement to execute.  If the limit is
     * exceeded, a java.sql.SQLException is thrown.
     *
     * @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 (Sql.indexOf("||") != -1) {
	    Sql = _Escaper.doConcat(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);
        }

	  if (_Conn.useMaxRows()) {
	      if (Sql.toUpperCase().indexOf("LIMIT") != -1) { 
		    RS = _Conn.execSQL(Sql, _max_rows);
		}
		else {
		    if (_max_rows <= 0) {
			_Conn.execSQL("SET OPTION SQL_SELECT_LIMIT=" 
				      + MysqlDefs.MAX_ROWS, -1);
		    }
		    else {
			_Conn.execSQL("SET OPTION SQL_SELECT_LIMIT=" + _max_rows,-1);
		    }                
		    RS = _Conn.execSQL(Sql, -1);
		}
	    }
	    else {
	      RS = _Conn.execSQL(Sql, -1);	    
	    }

          if (OldCatalog != null) {
            _Conn.setCatalog(OldCatalog);
          }
      }
	    
	_last_insert_id = RS.getUpdateID();

	if (RS != null) {
	    _Results = RS;
	}

	RS.setConnection(_Conn);

	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;
    }

    /**
     * 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_update_count = 0;
    
	if (_Results.getUpdateCount() > Integer.MAX_VALUE) {
	    truncated_update_count = Integer.MAX_VALUE;
	}
	else {
	    truncated_update_count = (int)_Results.getUpdateCount();
	}
    
	return truncated_update_count;
    }

    /**
     * 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 _update_count;
    }

    /**
     * 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 _last_insert_id;
    }

    /**
     * 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 (_NextResults != null) {
	    _Results = _NextResults;
	    _NextResults = null;
	    return true;
	}
	else {
	    return false;
	}
    }
}