/** * Set the maximum number of rows * * @param max the new max rows limit; zero means unlimited * @exception java.sql.SQLException if a database access error occurs * @see getMaxRows */ public void setMaxRows(int max) throws java.sql.SQLException { if (Driver.trace) { Object[] Args = {new Integer(max)}; Debug.methodCall(this, "setMaxRows", Args); } if (max > MysqlDefs.MAX_ROWS) { throw new java.sql.SQLException( "setMaxRows() out of range. " + max + " > " + MysqlDefs.MAX_ROWS + ".", "S1009"); } if (max == 0) { max = -1; } _max_rows = max; // Most people don't use setMaxRows() // so don't penalize them // with the extra query it takes // to do it efficiently unless we need // to. _Conn.maxRowsChanged(); }
/** * 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; }
/** * 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; }
/** * 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 }
/** * 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; }
/** * 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; }
/** * 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; }
/** * 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; }
/** * The maxFieldSize limit (in bytes) is the maximum amount of data returned for any column value; * it only applies to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR and LONGVARCHAR columns. If * the limit is exceeded, the excess data is silently discarded. * * @return the current max column size limit; zero means unlimited * @exception java.sql.SQLException if a database access error occurs */ public int getMaxFieldSize() throws java.sql.SQLException { if (Driver.trace) { Object[] Args = new Object[0]; Debug.methodCall(this, "getMaxFieldSize", Args); } return _max_field_size; // Init. set to MAXBUFFER in MysqlIO }
/** * 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 }
/** * 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; }
/** * Constructor for a Statement. It simply sets the connection that created us. * * @param c the Connection instantation that creates us */ public Statement(Connection C, String Catalog) { if (Driver.trace) { Object[] Args = {C}; Debug.methodCall(this, "constructor", Args); } _Conn = C; _Escaper = new EscapeProcessor(); _Catalog = Catalog; }
/** * Execute a SQL INSERT, UPDATE or DELETE statement. In addition SQL statements that return * nothing such as SQL DDL statements can be executed * * <p>Any IDs generated for AUTO_INCREMENT fields can be retrieved by casting this Statement to * org.gjt.mm.mysql.Statement and calling the getLastInsertID() method. * * @param Sql a SQL statement * @return either a row count, or 0 for SQL commands * @exception java.sql.SQLException if a database access error occurs */ public int executeUpdate(String Sql) throws java.sql.SQLException { if (Driver.trace) { Object[] Args = {Sql}; Debug.methodCall(this, "executeUpdate", Args); } if (_escapeProcessing) { Sql = _Escaper.escapeSQL(Sql); } if (Sql.indexOf("||") != -1) { Sql = _Escaper.doConcat(Sql); } // The checking and changing of catalogs // must happen in sequence, so synchronize // on the same mutex that _Conn is using ResultSet RS = null; synchronized (_Conn.getMutex()) { String OldCatalog = null; if (!_Conn.getCatalog().equals(_Catalog)) { OldCatalog = _Conn.getCatalog(); _Conn.setCatalog(_Catalog); } RS = _Conn.execSQL(Sql, -1); RS.setConnection(_Conn); if (OldCatalog != null) { _Conn.setCatalog(OldCatalog); } } if (RS.reallyResult()) { throw new java.sql.SQLException("Results returned for UPDATE ONLY.", "01S03"); } else { _update_count = RS.getUpdateCount(); int truncated_update_count = 0; if (_update_count > Integer.MAX_VALUE) { truncated_update_count = Integer.MAX_VALUE; } else { truncated_update_count = (int) _update_count; } _last_insert_id = RS.getUpdateID(); return truncated_update_count; } }
/** * In many cases, it is desirable to immediately release a Statement's database and JDBC resources * instead of waiting for this to happen when it is automatically closed. The close method * provides this immediate release. * * <p><B>Note:</B> A Statement is automatically closed when it is garbage collected. When a * Statement is closed, its current ResultSet, if one exists, is also closed. * * @exception java.sql.SQLException if a database access error occurs */ public void close() throws java.sql.SQLException { if (Driver.trace) { Object[] Args = new Object[0]; Debug.methodCall(this, "close", Args); } _Results = null; _Conn = null; _Warnings = null; _Escaper = null; }
/** * Sets the maxFieldSize * * @param max the new max column size limit; zero means unlimited * @exception java.sql.SQLException if size exceeds buffer size */ public void setMaxFieldSize(int max) throws java.sql.SQLException { if (Driver.trace) { Object[] Args = {new Integer(max)}; Debug.methodCall(this, "setMaxFieldSize", Args); } if (max > MysqlIO.MAXBUF) throw new java.sql.SQLException( "Attempt to set max field size > " + MysqlIO.MAXBUF + " (compile time default)", "S1009"); else _max_field_size = max; }
/** * The maxRows limit is set to limit the number of rows that any ResultSet can contain. If the * limit is exceeded, the excess rows are silently dropped. * * @return the current maximum row limit; zero means unlimited * @exception java.sql.SQLException if a database access error occurs */ public int getMaxRows() throws java.sql.SQLException { if (Driver.trace) { Object[] Args = new Object[0]; Debug.methodCall(this, "getMaxRows", Args); } if (_max_rows <= 0) { return 0; } else { return _max_rows; } }
/** * 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; } }
/** * 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; }
/** * 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; }
/** * Execute a SQL statement that retruns a single ResultSet * * @param Sql typically a static SQL SELECT statement * @return a ResulSet that contains the data produced by the query * @exception java.sql.SQLException if a database access error occurs */ public java.sql.ResultSet executeQuery(String Sql) throws java.sql.SQLException { if (Driver.trace) { Object[] Args = {Sql}; Debug.methodCall(this, "executeQuery", Args); } if (_escapeProcessing) { Sql = _Escaper.escapeSQL(Sql); } if (Sql.indexOf("||") != -1) { Sql = _Escaper.doConcat(Sql); } if (_Results != null) { _Results.close(); } // 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()) { // We need to execute this all together // So synchronize on the Connection's mutex (because // even queries going through there synchronize // on the connection if (Sql.toUpperCase().indexOf("LIMIT") != -1) { _Results = _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); } _Results = _Conn.execSQL(Sql, -1); if (OldCatalog != null) { _Conn.setCatalog(OldCatalog); } } } else { _Results = _Conn.execSQL(Sql, -1); } if (OldCatalog != null) { _Conn.setCatalog(OldCatalog); } } _last_insert_id = _Results.getUpdateID(); _NextResults = _Results; _Results.setConnection(_Conn); return _Results; }
/** * 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()); }