db-derby-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d..@apache.org
Subject svn commit: r125266 - in incubator/derby/code/trunk/java: engine/org/apache/derby/iapi/reference engine/org/apache/derby/iapi/sql engine/org/apache/derby/impl/jdbc engine/org/apache/derby/jdbc engine/org/apache/derby/loc testing/org/apache/derbyTesting/functionTests/master testing/org/apache/derbyTesting/functionTests/suites testing/org/apache/derbyTesting/functionTests/tests/lang
Date Sat, 15 Jan 2005 16:13:56 GMT
Author: djd
Date: Sat Jan 15 08:13:54 2005
New Revision: 125266

URL: http://svn.apache.org/viewcvs?view=rev&rev=125266
Log:
Derby-98 Implement ResultSet.deleteRow() for forward only ResultSets.

Contributed by Mamta Satoor.

Added:
   incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/updatableResultSet.out
   incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/updatableResultSet.java
Modified:
   incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/reference/SQLState.java
   incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/sql/ResultSet.java
   incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnection.java
   incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnectionContext.java
   incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedDatabaseMetaData.java
   incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet.java
   incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet20.java
   incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver169.java
   incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver20.java
   incubator/derby/code/trunk/java/engine/org/apache/derby/loc/messages_en.properties
   incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/scrollCursors2.out
   incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/triggerGeneral.out
   incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall
   incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/scrollCursors2.java
   incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/triggerGeneral.sql

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/reference/SQLState.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/reference/SQLState.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/reference/SQLState.java&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/reference/SQLState.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/reference/SQLState.java	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/reference/SQLState.java	Sat Jan 15 08:13:54 2005
@@ -1379,6 +1379,9 @@
     // (no message in message.properties)
     String BLOB_SETPOSITION_FAILED = "XJ079.S";
 
+    //updatable resultset related
+    String UPDATABLE_RESULTSET_API_DISALLOWED = "XJ083.U";
+
     //following are session severity.
     String DATABASE_NOT_FOUND = "XJ004.C";
     String LOGIN_FAILED = "08004";
@@ -1409,9 +1412,10 @@
     //following are warning severity.
     String DATABASE_EXISTS = "01J01";
     String NO_SCROLL_SENSITIVE_CURSORS = "01J02";
-    String NO_UPDATABLE_CONCURRENCY = "01J03";
+    String UPDATABLE_RESULTSET_FOR_FORWARD_ONLY = "01J03";
 	String LANG_TYPE_NOT_SERIALIZABLE = "01J04";
 	String UPGRADE_SPSRECOMPILEFAILED = "01J05";
+    String QUERY_NOT_QUALIFIED_FOR_UPDATABLE_RESULTSET = "01J06";
 
 
     //following are database severity

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/sql/ResultSet.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/sql/ResultSet.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/sql/ResultSet.java&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/sql/ResultSet.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/sql/ResultSet.java	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/iapi/sql/ResultSet.java	Sat Jan 15 08:13:54 2005
@@ -312,7 +312,7 @@
 	public NoPutResultSet[] getSubqueryTrackingArray(int numSubqueries);
 
 	/**
-	 * ResultSet for rowss inserted into the table (contains auto-generated keys columns only)
+	 * ResultSet for rows inserted into the table (contains auto-generated keys columns only)
 	 *
 	 * @return NoPutResultSet	NoPutResultSets for rows inserted into the table.
 	 */

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnection.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnection.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnection.java&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnection.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnection.java	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnection.java	Sat Jan 15 08:13:54 2005
@@ -478,7 +478,7 @@
 			throw Util.noCurrentConnection();
 
 		return factory.newEmbedStatement(this, false,
-			setResultSetType(resultSetType), setResultSetConcurrency(resultSetConcurrency),
+			setResultSetType(resultSetType), setResultSetConcurrency(resultSetType, resultSetConcurrency),
 			resultSetHoldability);
 	}
 
@@ -669,7 +669,7 @@
 			try {
 			    return factory.newEmbedPreparedStatement(this, sql, false,
 											   setResultSetType(resultSetType),
-											   setResultSetConcurrency(resultSetConcurrency),
+											   setResultSetConcurrency(resultSetType, resultSetConcurrency),
 											   resultSetHoldability,
 											   autoGeneratedKeys,
 											   columnIndexes,
@@ -762,7 +762,7 @@
 			{
 			    return factory.newEmbedCallableStatement(this, sql,
 											   setResultSetType(resultSetType),
-											   setResultSetConcurrency(resultSetConcurrency),
+											   setResultSetConcurrency(resultSetType, resultSetConcurrency),
 											   resultSetHoldability);
 			} 
 			finally 
@@ -1675,6 +1675,19 @@
 		return resultSetType;
 	}
 
+	private int setResultSetConcurrency(int resultSetType, int resultSetConcurrency) {
+
+		/* Add warning if updatable resultset is requested on cursor type other than forward only
+		 * and then downgrade the resultset to read only resultset.
+		 */
+		if (resultSetType != JDBC20Translation.TYPE_FORWARD_ONLY && resultSetConcurrency == JDBC20Translation.CONCUR_UPDATABLE)
+		{
+			addWarning(EmbedSQLWarning.newEmbedSQLWarning(SQLState.UPDATABLE_RESULTSET_FOR_FORWARD_ONLY));
+			resultSetConcurrency = JDBC20Translation.CONCUR_READ_ONLY;
+		}
+		return resultSetConcurrency;
+	}
+
 	
 
 	/** 
@@ -1719,19 +1732,6 @@
 	public int getPrepareIsolation()
 	{
 		return getLanguageConnection().getPrepareIsolationLevel();
-	}
-
-	private int setResultSetConcurrency(int resultSetConcurrency) {
-
-		/* Add warning if updatable concurrency
-		 * and downgrade to read only.
-		 */
-		if (resultSetConcurrency == JDBC20Translation.CONCUR_UPDATABLE)
-		{
-			addWarning(EmbedSQLWarning.newEmbedSQLWarning(SQLState.NO_UPDATABLE_CONCURRENCY));
-			resultSetConcurrency = JDBC20Translation.CONCUR_READ_ONLY;
-		}
-		return resultSetConcurrency;
 	}
 
 	/**

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnectionContext.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnectionContext.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnectionContext.java&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnectionContext.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnectionContext.java	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedConnectionContext.java	Sat Jan 15 08:13:54 2005
@@ -125,7 +125,7 @@
 	public java.sql.ResultSet getResultSet
 	(
 		ResultSet 				executionResultSet
-	)
+	) throws SQLException
 	{
 		EmbedConnection conn = (EmbedConnection) connRef.get();
 

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedDatabaseMetaData.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedDatabaseMetaData.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedDatabaseMetaData.java&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedDatabaseMetaData.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedDatabaseMetaData.java	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedDatabaseMetaData.java	Sat Jan 15 08:13:54 2005
@@ -2412,10 +2412,16 @@
      * @return true if so 
      * @see Connection
      */
-    public boolean supportsResultSetConcurrency(int type, int concurrency) {
-  		if ((type == JDBC20Translation.TYPE_SCROLL_SENSITIVE) ||
-        (concurrency == JDBC20Translation.CONCUR_UPDATABLE))
-		  return false;
+	public boolean supportsResultSetConcurrency(int type, int concurrency) {
+		//FORWARD_ONLY + CONCUR_UPDATABLE combination is supported (at this point, delete functionality only)
+		if ((type == JDBC20Translation.TYPE_FORWARD_ONLY) &&
+				(concurrency == JDBC20Translation.CONCUR_UPDATABLE))
+			return true;
+
+		//requesting CONCUR_UPDATABLE on any resultset type other than TYPE_FORWARD_ONLY will return false
+		if ((type == JDBC20Translation.TYPE_SCROLL_SENSITIVE) ||
+				(concurrency == JDBC20Translation.CONCUR_UPDATABLE))
+			return false;
 		return true;
 	}
 
@@ -2445,14 +2451,26 @@
      * @param result set type, i.e. ResultSet.TYPE_XXX
      * @return true if changes are visible for the result set type
      */
+    //Since Derby materializes a forward only ResultSet incrementally, it is possible to see changes
+    //made by others and hence following 3 metadata calls will return true for forward only ResultSets.
+    //Scroll insensitive ResultSet by their definition do not see chnages made by others.
+    //Derby does not yet implement scroll sensitive resultsets.
     public boolean othersUpdatesAreVisible(int type) {
-		  return true;
+		if (type == JDBC20Translation.TYPE_FORWARD_ONLY)
+			return true;
+		return false;
 	}
+
     public boolean othersDeletesAreVisible(int type)  {
-		  return true;
+		if (type == JDBC20Translation.TYPE_FORWARD_ONLY)
+			return true;
+		return false;
 	}
+
     public boolean othersInsertsAreVisible(int type)  {
-		  return true;
+		if (type == JDBC20Translation.TYPE_FORWARD_ONLY)
+			return true;
+		return false;
 	}
 
     /**

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet.java&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet.java	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet.java	Sat Jan 15 08:13:54 2005
@@ -84,7 +84,9 @@
 
 	// mutable state
 	protected ExecRow currentRow;
-	private DataValueDescriptor[] rowData;
+	//rowData is protected so deleteRow in EmbedResultSet20.java can make it null.
+	//This ensures that after deleteRow, ResultSet is not positioned on the deleted row.
+	protected DataValueDescriptor[] rowData;
 	protected boolean wasNull;
 	protected boolean isClosed;
 	private Object	currentStream;
@@ -131,6 +133,7 @@
 
 	protected final boolean isAtomic;
 
+	protected final int concurrencyOfThisResultSet;
 
 	/**
 	 * This class provides the glue between the Cloudscape
@@ -138,7 +141,7 @@
 	 */
 	public EmbedResultSet(EmbedConnection conn, ResultSet resultsToWrap,
 		boolean forMetaData, EmbedStatement stmt, boolean isAtomic) 
-        {
+        throws SQLException {
 
 		super(conn);
 
@@ -149,6 +152,27 @@
 		this.stmt = owningStmt = stmt;
 		this.isAtomic = isAtomic;
 
+		//If the Statement object has CONCUR_READ_ONLY set on it then the concurrency on the ResultSet object will be CONCUR_READ_ONLY also.
+		//But, if the Statement object has CONCUR_UPDATABLE set on it, then the concurrency on the ResultSet object can be
+		//CONCUR_READ_ONLY or CONCUR_UPDATABLE depending on whether the underlying language resultset is updateable or not.
+		//If the underlying language resultset is not updateable, then the concurrency of the ResultSet object will be CONCUR_READ_ONLY
+		//and a warning will be issued on the ResultSet object.
+		if (stmt == null) concurrencyOfThisResultSet = JDBC20Translation.CONCUR_READ_ONLY;
+		else if (stmt.getResultSetConcurrency() == JDBC20Translation.CONCUR_READ_ONLY)
+			concurrencyOfThisResultSet = JDBC20Translation.CONCUR_READ_ONLY;
+		else {
+			if (!isForUpdate()) { //language resultset not updatable
+				concurrencyOfThisResultSet = JDBC20Translation.CONCUR_READ_ONLY;
+				SQLWarning w = StandardException.newWarning(SQLState.QUERY_NOT_QUALIFIED_FOR_UPDATABLE_RESULTSET);
+				if (topWarning == null)
+					topWarning = w;
+				else
+					topWarning.setNextWarning(w);
+			} else
+					concurrencyOfThisResultSet = JDBC20Translation.CONCUR_UPDATABLE;
+		}
+
+		// Fill in the column types
 		resultDescription = theResults.getResultDescription();
 
         // assign the max rows and maxfiled size limit for this result set

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet20.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet20.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet20.java&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet20.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet20.java	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/impl/jdbc/EmbedResultSet20.java	Sat Jan 15 08:13:54 2005
@@ -23,8 +23,11 @@
 import org.apache.derby.iapi.reference.JDBC20Translation;
 import org.apache.derby.iapi.reference.SQLState;
 
+import org.apache.derby.iapi.sql.Activation;
 import org.apache.derby.iapi.sql.ResultSet;
 
+import org.apache.derby.iapi.sql.execute.ExecCursorTableReference;
+
 import org.apache.derby.iapi.error.StandardException;
 import org.apache.derby.impl.jdbc.Util;
 import org.apache.derby.iapi.sql.conn.LanguageConnectionContext;
@@ -75,7 +78,7 @@
                                                          boolean forMetaData,
                                                          org.apache.derby.impl.jdbc.EmbedStatement stmt,
                                                          boolean isAtomic)  
-        {
+        throws SQLException {
                 super(conn, resultsToWrap, forMetaData, stmt, isAtomic);
         }
 
@@ -214,7 +217,7 @@
          * @exception SQLException Thrown on error.
      */
     public boolean isAfterLast() throws SQLException 
-        {
+          {
                 return checkRowPosition(ResultSet.ISAFTERLAST, "isAfterLast");
         }
  
@@ -519,15 +522,19 @@
     /**
      * JDBC 2.0
      *
-     * Return the concurrency of this result set.  The concurrency
-     * used is determined by the statement that created the result set.
+     * Return the concurrency of this result set.  The concurrency is determined as follows
+     * If Statement object has CONCUR_READ_ONLY concurrency, then ResultSet object will also have the CONCUR_READ_ONLY concurrency.
+     * But if Statement object has CONCUR_UPDATABLE concurrency, then the concurrency of ResultSet object depends on whether the
+     * underlying language resultset is updatable or not. If the language resultset is updatable, then JDBC ResultSet object will
+     * also have the CONCUR_UPDATABLE concurrency. If lanugage resultset is not updatable, then JDBC ResultSet object concurrency
+     * will be set to CONCUR_READ_ONLY.
      *
      * @return the concurrency type, CONCUR_READ_ONLY, etc.
      * @exception SQLException if a database-access error occurs
      */
     public int getConcurrency() throws SQLException 
         {
-                return JDBC20Translation.CONCUR_READ_ONLY;
+                return concurrencyOfThisResultSet;
         }
 
     //---------------------------------------------------------------------
@@ -579,7 +586,7 @@
      * @see EmbedDatabaseMetaData#deletesAreDetected
      */
     public boolean rowDeleted() throws SQLException {
-                throw Util.notImplemented();
+        return false;
         }
 
     /**
@@ -1336,8 +1343,49 @@
      * called when on the insert row.
      */
     public void deleteRow() throws SQLException {
-                throw Util.notImplemented();
-        }
+        synchronized (getConnectionSynchronization()) {
+            checkIfClosed("deleteRow");
+            checkOnRow(); // first make sure there's a current row
+
+            if (getConcurrency() != JDBC20Translation.CONCUR_UPDATABLE)//if not updatable resultset, can't issue deleteRow
+                throw Util.generateCsSQLException(SQLState.UPDATABLE_RESULTSET_API_DISALLOWED, "deleteRow");
+
+            setupContextStack();
+            try {
+                //in case of autocommit on, if there was an exception which caused runtime rollback in this transaction prior to this deleteRow,
+                //the rollback code will mark the language resultset closed (it doesn't mark the JDBC ResultSet closed).
+                //That is why alongwith the earlier checkIfClosed call in this method, there is a check for language resultset close as well.
+                if (theResults.isClosed())
+                    throw Util.generateCsSQLException(SQLState.LANG_RESULT_SET_NOT_OPEN, "deleteRow");
+                StringBuffer deleteWhereCurrentOfSQL = new StringBuffer("DELETE FROM ");
+                Activation activation = getEmbedConnection().getLanguageConnection().lookupCursorActivation(getCursorName());
+                deleteWhereCurrentOfSQL.append(getFullBaseTableName(activation.getPreparedStatement().getTargetTable()));//get the underlying (schema.)table name
+                //using quotes around the cursor name to preserve case sensitivity
+                deleteWhereCurrentOfSQL.append(" WHERE CURRENT OF \"" + getCursorName() + "\"");
+
+                LanguageConnectionContext lcc = getEmbedConnection().getLanguageConnection();
+                StatementContext statementContext = lcc.pushStatementContext(isAtomic, deleteWhereCurrentOfSQL.toString(), null, false);
+                org.apache.derby.iapi.sql.PreparedStatement ps = lcc.prepareInternalStatement(deleteWhereCurrentOfSQL.toString());
+                org.apache.derby.iapi.sql.ResultSet rs = ps.execute(lcc, true);
+                rs.close();
+                rs.finish();
+                //For forward only resultsets, after a delete, the ResultSet will be positioned right before the next row.
+                rowData = null;
+                lcc.popStatementContext(statementContext, null);
+            } catch (StandardException t) {
+                    throw closeOnTransactionError(t);
+            } finally {
+                restoreContextStack();
+            }
+        }
+    }
+
+    private String getFullBaseTableName(ExecCursorTableReference targetTable) {
+		if (targetTable.getSchemaName() != null)
+			return targetTable.getSchemaName() + "." + targetTable.getBaseName();
+		else
+			return targetTable.getBaseName();
+    }
 
     /**
      * JDBC 2.0

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver169.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver169.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver169.java&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver169.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver169.java	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver169.java	Sat Jan 15 08:13:54 2005
@@ -482,8 +482,8 @@
 		return new EmbedDatabaseMetaData(conn,dbname);
 	}
 
-	public abstract EmbedResultSet 
-		newEmbedResultSet(EmbedConnection conn, ResultSet results, boolean forMetaData, EmbedStatement statement, boolean isAtomic) ;
+	public abstract EmbedResultSet
+		newEmbedResultSet(EmbedConnection conn, ResultSet results, boolean forMetaData, EmbedStatement statement, boolean isAtomic) throws SQLException;
 //	{
 //		return new EmbedResultSet(conn, results, forMetaData, statement, isAtomic, false);
 //	}

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver20.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver20.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver20.java&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver20.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver20.java	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/jdbc/Driver20.java	Sat Jan 15 08:13:54 2005
@@ -157,6 +157,7 @@
   
 	public org.apache.derby.impl.jdbc.EmbedResultSet 
 	newEmbedResultSet(EmbedConnection conn, ResultSet results, boolean forMetaData, org.apache.derby.impl.jdbc.EmbedStatement statement, boolean isAtomic)
+		throws SQLException
 	{
 		return new EmbedResultSet20(conn, results, forMetaData, statement,
 								 isAtomic); 

Modified: incubator/derby/code/trunk/java/engine/org/apache/derby/loc/messages_en.properties
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/engine/org/apache/derby/loc/messages_en.properties?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/engine/org/apache/derby/loc/messages_en.properties&r1=125265&p2=incubator/derby/code/trunk/java/engine/org/apache/derby/loc/messages_en.properties&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/engine/org/apache/derby/loc/messages_en.properties	(original)
+++ incubator/derby/code/trunk/java/engine/org/apache/derby/loc/messages_en.properties	Sat Jan 15 08:13:54 2005
@@ -1081,6 +1081,7 @@
 XJ076.S=The position argument ''{0}'' exceeds the size of the Blob/Clob.
 XJ077.S=Got an exception when trying to read the first byte/character of the Blob/Clob pattern using getBytes/getSubString.
 XJ082.U=BLOB/CLOB values are not allowed as method parameters or receiver.
+XJ083.U=''{0}'' not allowed because the ResultSet is not an updatable ResultSet. 
 
 0A000.S=Feature not implemented: {0}.
 
@@ -1103,9 +1104,10 @@
 
 01J01=Database ''{0}'' not created, connection made to existing database instead.
 01J02=Scroll sensitive cursors are not currently implemented.
-01J03=Updatable ResultSets are not currently implemented.
+01J03=Scroll sensitive and scroll insensitive updatable ResultSets are not currently implemented.
 01J04=The class ''{0}'' for column ''{1}'' does not implement java.io.Serializable or java.sql.SQLData. Instances must implement one of these interfaces to allow them to be stored.
 01J05=Database upgrade succeeded. The upgraded database is now ready for use. Revalidating stored prepared statements failed. See next exception for details of failure.
+01J06=ResultSet not updatable. Query does not qualify to generate an updatable ResultSet.
 
 XJ001.U=Java exception: ''{1}: {0}''.
 XJ050.U=Database requires upgrade from version {0}, set the attribute ''upgrade=true'' on the JDBC connection URL to allow upgrade to version {1}.

Modified: incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/scrollCursors2.out
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/scrollCursors2.out?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/scrollCursors2.out&r1=125265&p2=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/scrollCursors2.out&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/scrollCursors2.out	(original)
+++ incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/scrollCursors2.out	Sat Jan 15 08:13:54 2005
@@ -1,15 +1,12 @@
 Test scrollCurors2 starting
-warning = SQL Warning: Updatable ResultSets are not currently implemented.
-warning = SQL Warning: Updatable ResultSets are not currently implemented.
 warning = SQL Warning: Scroll sensitive cursors are not currently implemented.
 warning = SQL Warning: Scroll sensitive cursors are not currently implemented.
-warning = SQL Warning: Updatable ResultSets are not currently implemented.
-warning = SQL Warning: Updatable ResultSets are not currently implemented.
-warning = SQL Warning: Updatable ResultSets are not currently implemented.
+warning = SQL Warning: Scroll sensitive and scroll insensitive updatable ResultSets are not currently implemented.
+warning = SQL Warning: Scroll sensitive and scroll insensitive updatable ResultSets are not currently implemented.
+warning = SQL Warning: Scroll sensitive and scroll insensitive updatable ResultSets are not currently implemented.
 warning = SQL Warning: Scroll sensitive cursors are not currently implemented.
 warning = SQL Warning: Scroll sensitive cursors are not currently implemented.
-warning = SQL Warning: Updatable ResultSets are not currently implemented.
-warning = SQL Warning: Updatable ResultSets are not currently implemented.
-warning = SQL Warning: Updatable ResultSets are not currently implemented.
+warning = SQL Warning: Scroll sensitive and scroll insensitive updatable ResultSets are not currently implemented.
+warning = SQL Warning: Scroll sensitive and scroll insensitive updatable ResultSets are not currently implemented.
 PASS
 Test scrollCursors2 finished

Modified: incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/triggerGeneral.out
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/triggerGeneral.out?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/triggerGeneral.out&r1=125265&p2=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/triggerGeneral.out&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/triggerGeneral.out	(original)
+++ incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/triggerGeneral.out	Sat Jan 15 08:13:54 2005
@@ -36,11 +36,11 @@
 1         |&|&|&|&|REFERENCEDCOLU&
 ----------------------------------
 T1        |U|B|R|E|(1,2)          
-ij> select cast(triggername as char(10)), text from sys.systriggers t, sys.sysstatements s 
+ij> select cast(triggername as char(10)), CAST (TRIGGERDEFINITION AS VARCHAR(180)), STMTNAME from sys.systriggers t, sys.sysstatements s 
 		where s.stmtid = t.actionstmtid;
-1         |TEXT                                                                                                                            
--------------------------------------------------------------------------------------------------------------------------------------------
-T1        |values 1                                                                                                                        
+1         |2                                                                                                                               |STMTNAME                                                                                                                        
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+T1        |values 1                                                                                                                        |TRIGGERACTN_xxxxFILTERED-UUIDxxxx_xxxxFILTERED-UUIDxxxx                                           
 ij> select cast(triggername as char(10)), tablename from sys.systriggers t, sys.systables tb
 		where t.tableid = tb.tableid;
 1         |TABLENAME                                                                                                                       
@@ -941,16 +941,14 @@
 1 row inserted/updated/deleted
 ij> create trigger "tt1" after insert on trigtable
 referencing NEW as NEW for each row mode db2sql
-insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values
-(new."cOlUmN1" + 5, "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", 5);
+insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values (new."cOlUmN1" + 5, "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", 5);
 0 rows inserted/updated/deleted
 ij> maximumdisplaywidth 2000;
-ij> select cast(triggername as char(10)), text from sys.systriggers t, sys.sysstatements s 
+ij> select cast(triggername as char(10)), CAST (TRIGGERDEFINITION AS VARCHAR(180)), STMTNAME from sys.systriggers t, sys.sysstatements s 
 		where s.stmtid = t.actionstmtid and triggername = 'tt1';
-1         |TEXT                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-tt1       |insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values
-(cast (org.apache.derby.iapi.db.Factory::getTriggerExecutionContext().getNewRow().getObject('cOlUmN1') AS INTEGER)  + 5, cast (org.apache.derby.iapi.db.Factory::getTriggerExecutionContext().getNewRow().getObject('cOlUmN2  ') AS INTEGER)  * cast (org.apache.derby.iapi.db.Factory::getTriggerExecutionContext().getNewRow().getObject('cOlUmN3""  ') AS INTEGER) , 5)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
+1         |2                                                                                                                                                                                   |STMTNAME                                                                                                                        
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+tt1       |insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values (new."cOlUmN1" + 5, "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", 5)                                            |TRIGGERACTN_xxxxFILTERED-UUIDxxxx_xxxxFILTERED-UUIDxxxx                                           
 ij> insert into trigtable values (1, 2, 3);
 1 row inserted/updated/deleted
 ij> select * from trighistory;
@@ -961,15 +959,13 @@
 0 rows inserted/updated/deleted
 ij> create trigger "tt1" after insert on trigtable
 referencing new as new for each row mode db2sql
-insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values
-(new."cOlUmN1" + new."cOlUmN1", "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", new."cOlUmN2  " * 3);
+insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values (new."cOlUmN1" + new."cOlUmN1", "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", new."cOlUmN2  " * 3);
 0 rows inserted/updated/deleted
-ij> select cast(triggername as char(10)), text from sys.systriggers t, sys.sysstatements s 
+ij> select cast(triggername as char(10)), CAST (TRIGGERDEFINITION AS VARCHAR(180)), STMTNAME from sys.systriggers t, sys.sysstatements s 
 		where s.stmtid = t.actionstmtid and triggername = 'tt1';
-1         |TEXT                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-tt1       |insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values
-(cast (org.apache.derby.iapi.db.Factory::getTriggerExecutionContext().getNewRow().getObject('cOlUmN1') AS INTEGER)  + cast (org.apache.derby.iapi.db.Factory::getTriggerExecutionContext().getNewRow().getObject('cOlUmN1') AS INTEGER) , cast (org.apache.derby.iapi.db.Factory::getTriggerExecutionContext().getNewRow().getObject('cOlUmN2  ') AS INTEGER)  * cast (org.apache.derby.iapi.db.Factory::getTriggerExecutionContext().getNewRow().getObject('cOlUmN3""  ') AS INTEGER) , cast (org.apache.derby.iapi.db.Factory::getTriggerExecutionContext().getNewRow().getObject('cOlUmN2  ') AS INTEGER)  * 3)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+1         |2                                                                                                                                                                                   |STMTNAME                                                                                                                        
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+tt1       |insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values (new."cOlUmN1" + new."cOlUmN1", "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", new."cOlUmN2  " * 3)              |TRIGGERACTN_xxxxFILTERED-UUIDxxxx_xxxxFILTERED-UUIDxxxx                                           
 ij> insert into trigtable values (1, 2, 3);
 1 row inserted/updated/deleted
 ij> select * from trighistory;

Added: incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/updatableResultSet.out
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/updatableResultSet.out?view=auto&rev=125266
==============================================================================
--- (empty file)
+++ incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/master/updatableResultSet.out	Sat Jan 15 08:13:54 2005
@@ -0,0 +1,222 @@
+Start testing delete using JDBC2.0 updateable resultset apis
+---Negative Testl - request for scroll insensitive updatable resultset will give a read only scroll insensitive resultset
+warnings on connection = SQL Warning: Scroll sensitive and scroll insensitive updatable ResultSets are not currently implemented.
+requested TYPE_SCROLL_INSENSITIVE, CONCUR_UPDATABLE but that is not supported
+Make sure that we got TYPE_SCROLL_INSENSITIVE? true
+Make sure that we got CONCUR_READ_ONLY? true
+ownDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE)? false
+othersDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE)? false
+deletesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE)? false
+JDBC 2.0 updatable resultset api will fail on this resultset because this is not an updatable resultset
+Got expected exception 'deleteRow' not allowed because the ResultSet is not an updatable ResultSet. 
+---Negative Test2 - request for scroll sensitive updatable resultset will give a read only scroll insensitive resultset
+requested TYPE_SCROLL_SENSITIVE, CONCUR_UPDATABLE but that is not supported
+Make sure that we got TYPE_SCROLL_INSENSITIVE? true
+Make sure that we got CONCUR_READ_ONLY? true
+JDBC 2.0 updatable resultset api will fail on this resultset because this is not an updatable resultset
+Got expected exception 'deleteRow' not allowed because the ResultSet is not an updatable ResultSet. 
+---Negative Test3 - request a read only resultset and attempt deleteRow on it
+Make sure that we got CONCUR_READ_ONLY? true
+Now attempting to send a deleteRow on a read only resultset.
+Got expected exception 'deleteRow' not allowed because the ResultSet is not an updatable ResultSet. 
+---Negative Test4 - request a read only resultset and send a sql with FOR UPDATE clause and attempt deleteRow on it
+Make sure that we got CONCUR_READ_ONLY? true
+Now attempting to send a deleteRow on a read only resultset with FOR UPDATE clause in the SELECT sql.
+Got expected exception 'deleteRow' not allowed because the ResultSet is not an updatable ResultSet. 
+---Negative Test5 - request updatable resultset for sql with no FOR UPDATE clause
+Make sure that we got CONCUR_READ_ONLY? true
+Expected warnings on resultset = java.sql.SQLWarning: ResultSet not updatable. Query does not qualify to generate an updatable ResultSet.
+Now attempting to send a delete on a sql with no FOR UPDATE clause.
+Got expected exception 'deleteRow' not allowed because the ResultSet is not an updatable ResultSet. 
+---Negative Test6 - request updatable resultset for sql with FOR READ ONLY clause
+Make sure that we got CONCUR_READ_ONLY? true
+Expected warnings on resultset = java.sql.SQLWarning: ResultSet not updatable. Query does not qualify to generate an updatable ResultSet.
+Now attempting to send a delete on a sql with FOR READ ONLY clause.
+Got expected exception 'deleteRow' not allowed because the ResultSet is not an updatable ResultSet. 
+---Negative Test7 - attempt to deleteRow on updatable resultset when the resultset is not positioned on a row
+Make sure that we got CONCUR_UPDATABLE? true
+Now attempt a deleteRow without first doing next on the resultset.
+Got expected exception Invalid cursor state - no current row.
+ResultSet is positioned after the last row. attempt to deleteRow at this point should fail!
+Got expected exception Invalid cursor state - no current row.
+---Negative Test8 - attempt deleteRow on updatable resultset after closing the resultset
+Make sure that we got CONCUR_UPDATABLE? true
+Got expected exception ResultSet not open, operation 'deleteRow' not permitted. Verify that autocommit is OFF.
+---Negative Test9 - try updatable resultset on system table
+expected exception FOR UPDATE is not permitted on this type of statement.
+---Negative Test10 - try updatable resultset on a view
+expected exception FOR UPDATE is not permitted on this type of statement.
+---Negative Test11 - attempt to open updatable resultset when there is join in the select query should fail
+expected exception FOR UPDATE is not permitted on this type of statement.
+---Negative Test12 - With autocommit on, attempt to drop a table when there is an open updatable resultset on it
+Opened an updatable resultset. Now trying to drop that table through another Statement
+expected exception Operation 'DROP TABLE' cannot be performed on object 'T1' because there is an open ResultSet dependent on that object.
+Since autocommit is on, the drop table exception resulted in a runtime rollback causing updatable resultset object to close
+expected exception ResultSet not open, operation 'deleteRow' not permitted. Verify that autocommit is OFF.
+---Negative Test13 - foreign key constraint failure will cause deleteRow to fail
+expected exception DELETE on table 'TABLEWITHPRIMARYKEY' caused a violation of foreign key constraint 'FK' for key (1,1).  The statement has been rolled back.
+Since autocommit is on, the constraint exception resulted in a runtime rollback causing updatable resultset object to close
+expected exception ResultSet not open, operation 'next' not permitted. Verify that autocommit is OFF.
+---Positive Test1 - request updatable resultset for forward only type resultset
+requested TYPE_FORWARD_ONLY, CONCUR_UPDATABLE
+got TYPE_FORWARD_ONLY? true
+got CONCUR_UPDATABLE? true
+JDBC 2.0 updatable resultset apis on this ResultSet object will pass because this is an updatable resultset
+column 1 on this row before deleteRow is 1
+column 2 on this row before deleteRow is aa                  
+Since after deleteRow(), ResultSet is positioned before the next row, getXXX will fail
+Got expected exception Invalid cursor state - no current row.
+calling deleteRow again w/o first positioning the ResultSet on the next row will fail
+Got expected exception Invalid cursor state - no current row.
+Position the ResultSet with next()
+Should be able to deletRow() on the current row now
+---Positive Test2 - even if no columns from table specified in the column list, we should be able to get updatable resultset
+total number of rows in T1 
+	 1
+	 -
+	{3}
+column 1 on this row is 1
+total number of rows in T1 after one deleteRow is 
+	 1
+	 -
+	{2}
+---Positive Test3 - use prepared statement with concur updatable status
+requested TYPE_FORWARD_ONLY, CONCUR_UPDATABLE
+got TYPE_FORWARD_ONLY? true
+got CONCUR_UPDATABLE? true
+column 1 on this row is 1
+Since after deleteRow(), ResultSet is positioned before the next row, getXXX will fail
+Got expected exception Invalid cursor state - no current row.
+calling deleteRow again w/o first positioning the ResultSet on the next row will fail
+Got expected exception Invalid cursor state - no current row.
+Position the ResultSet with next()
+Should be able to deletRow() on the current row now
+---Positive Test4 - use callable statement with concur updatable status
+requested TYPE_FORWARD_ONLY, CONCUR_UPDATABLE
+got TYPE_FORWARD_ONLY? true
+got CONCUR_UPDATABLE? true
+row not deleted yet. Confirm with rs.rowDeleted()? false
+column 1 on this row is 1
+Since after deleteRow(), ResultSet is positioned before the next row, getXXX will fail
+Got expected exception Invalid cursor state - no current row.
+calling deleteRow again w/o first positioning the ResultSet on the next row will fail
+Got expected exception Invalid cursor state - no current row.
+Position the ResultSet with next()
+Should be able to deletRow() on the current row now
+---Positive Test5 - donot have to select primary key to get an updatable resultset
+column 1 on this row is 1
+now try to delete row when primary key is not selected for that row
+---Positive Test6 - For Forward Only resultsets, DatabaseMetaData will return false for ownDeletesAreVisible and deletesAreDetected
+---This is because, after deleteRow, we position the ResultSet before the next row. We don't make a hole for the deleted row and then stay on that deleted hole
+ownDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY)? false
+othersDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY)? true
+deletesAreDetected(ResultSet.TYPE_FORWARD_ONLY)? false
+The JDBC program should look at rowDeleted only if deletesAreDetected returns true
+Since Derby returns false for detlesAreDetected for FORWARD_ONLY updatable resultset,the program should not rely on rs.rowDeleted() for FORWARD_ONLY updatable resultsets
+Have this call to rs.rowDeleted() just to make sure the method does always return false? false
+Have this call to rs.rowDeleted() just to make sure the method does always return false? false
+---Positive Test7 - delete using updatable resultset api from a temporary table
+following rows in temp table before deleteRow
+	 C21,C22
+	 --- ---
+	{21,1}
+	{22,1}
+As expected, no rows in temp table after deleteRow
+	 C21,C22
+	 --- ---
+---Positive Test8 - change the name of the resultset and see if deleteRow still works
+change the cursor name(case sensitive name) with setCursorName and then try to deleteRow
+change the cursor name one more time with setCursorName and then try to deleteRow
+---Positive Test9 - using correlation name for the table in the select sql is not a problem
+column 1 on this row is 1
+now try to deleteRow
+---Positive Test10 - 2 updatable resultsets going against the same table, will they conflict?
+delete using first resultset
+attempt to send deleteRow on the same row through a different resultset should throw an exception
+Got expected exception Cursor 'SQLCUR10' is not on a row.
+Move to next row in the 2nd resultset and then delete using the second resultset
+---Positive Test11 - setting the fetch size to > 1 will be ignored by updatable resultset. Same as updatable cursors
+Notice the Fetch Size in run time statistics output.
+1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+Statement Name: 
+	null
+Statement Text: 
+	SELECT 1, 2 FROM t1 FOR UPDATE of c1
+Parse Time: 0
+Bind Time: 0
+Optimize Time: 0
+Generate Time: 0
+Compile Time: 0
+Execute Time: 0
+Begin Compilation Timestamp : null
+End Compilation Timestamp : null
+Begin Execution Timestamp : null
+End Execution Timestamp : null
+Statement Execution Plan Text: 
+Project-Restrict ResultSet (3):
+Number of opens = 1
+Rows seen = 0
+Rows filtered = 0
+restriction = false
+projection = true
+	constructor time (milliseconds) = 0
+	open time (milliseconds) = 0
+	next time (milliseconds) = 0
+	close time (milliseconds) = 0
+	restriction time (milliseconds) = 0
+	projection time (milliseconds) = 0
+Source result set:
+	Project-Restrict ResultSet (2):
+	Number of opens = 1
+	Rows seen = 0
+	Rows filtered = 0
+	restriction = false
+	projection = true
+		constructor time (milliseconds) = 0
+		open time (milliseconds) = 0
+		next time (milliseconds) = 0
+		close time (milliseconds) = 0
+		restriction time (milliseconds) = 0
+		projection time (milliseconds) = 0
+	Source result set:
+		Table Scan ResultSet for T1 at read committed isolation level using exclusive row locking chosen by the optimizer
+		Number of opens = 1
+		Rows seen = 0
+		Rows filtered = 0
+		Fetch Size = 1
+			constructor time (milliseconds) = 0
+			open time (milliseconds) = 0
+			next time (milliseconds) = 0
+			close time (milliseconds) = 0
+		scan information: 
+			Bit set of columns fetched=All
+			Number of columns fetched=2
+			Number of pages visited=0
+			Number of rows qualified=0
+			Number of rows visited=0
+			Scan type=heap
+			start position: 
+null			stop position: 
+null			qualifiers:
+None
+statement's fetch size is 200
+---Positive Test12 - make sure delete trigger gets fired when deleteRow is issued
+Verify that before delete trigger got fired, row count is 0 in deleteTriggerInsertIntoThisTable
+	 1
+	 -
+	{0}
+column 1 on this row is 1
+now try to delete row and make sure that trigger got fired
+Verify that delete trigger got fired by verifying the row count to be 1 in deleteTriggerInsertIntoThisTable
+	 1
+	 -
+	{1}
+---Positive Test13 - With autocommit off, attempt to drop a table when there is an open updatable resultset on it
+Opened an updatable resultset. Now trying to drop that table through another Statement
+expected exception Operation 'DROP TABLE' cannot be performed on object 'T1' because there is an open ResultSet dependent on that object.
+Since autocommit is off, the drop table exception will NOT result in a runtime rollback and hence updatable resultset object is still open
+---Positive Test14 - After deleteRow, resultset is positioned before the next row
+getXXX right after deleteRow will fail because resultset is not positioned on a row, instead it is right before the next row
+expected exception Invalid cursor state - no current row.
+Finished testing updateable resultsets

Modified: incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall&r1=125265&p2=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall	(original)
+++ incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/suites/derbylang.runall	Sat Jan 15 08:13:54 2005
@@ -127,6 +127,7 @@
 lang/ungroupedAggregatesNegative.sql
 lang/union.sql
 lang/unlimited.sql
+lang/updatableResultSet.java
 lang/update.sql
 lang/updateCursor.java
 lang/valuesclause.sql

Modified: incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/scrollCursors2.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/scrollCursors2.java?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/scrollCursors2.java&r1=125265&p2=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/scrollCursors2.java&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/scrollCursors2.java	(original)
+++ incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/scrollCursors2.java	Sat Jan 15 08:13:54 2005
@@ -173,11 +173,9 @@
 	{
 		boolean		passed = true;
 		PreparedStatement	ps_f_r = null;
-		PreparedStatement	ps_f_u = null;
 		ResultSet	rs;
 		SQLWarning	warning;
 		Statement	s_f_r = null;
-		Statement	s_f_u = null;
 
 		s_f_r = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,
 									 ResultSet.CONCUR_READ_ONLY);
@@ -362,34 +360,6 @@
 		rs.close();
 		s_f_r.close();
 
-		s_f_u = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,
-									 ResultSet.CONCUR_UPDATABLE);
-		// We should have gotten 1 warning and a read only forward only cursor
-		warning = conn.getWarnings();
-		while (warning != null)
-		{
-			System.out.println("warning = " + warning);
-			warning = warning.getNextWarning();
-		}
-		conn.clearWarnings();
-
-		// Verify that result set from statement is 
-		// scroll insensitive and read only
-		rs = s_f_u.executeQuery("select * from t");
-		if (rs.getType() != ResultSet.TYPE_FORWARD_ONLY)
-		{
-			System.out.println("cursor type = " + rs.getType() +
-							   ", not " + ResultSet.TYPE_FORWARD_ONLY);
-		}
-		if (rs.getConcurrency() != ResultSet.CONCUR_READ_ONLY)
-		{
-			System.out.println("concurrency = " + rs.getConcurrency() +
-							   ", not " + ResultSet.CONCUR_READ_ONLY);
-		}
-
-		rs.close();
-
-
 		ps_f_r = conn.prepareStatement(
 									 "select * from t",
 									 ResultSet.TYPE_FORWARD_ONLY,
@@ -433,36 +403,6 @@
 		rs.close();
 		ps_f_r.close();
 
-		ps_f_u = conn.prepareStatement(
-									 "select * from t",
-									 ResultSet.TYPE_FORWARD_ONLY,
-									 ResultSet.CONCUR_UPDATABLE);
-		// We should have gotten 1 warning and a read only forward only cursor
-		warning = conn.getWarnings();
-		while (warning != null)
-		{
-			System.out.println("warning = " + warning);
-			warning = warning.getNextWarning();
-		}
-		conn.clearWarnings();
-
-		// Verify that result set from statement is 
-		// scroll insensitive and read only
-		rs = ps_f_u.executeQuery();
-		if (rs.getType() != ResultSet.TYPE_FORWARD_ONLY)
-		{
-			System.out.println("cursor type = " + rs.getType() +
-							   ", not " + ResultSet.TYPE_FORWARD_ONLY);
-		}
-		if (rs.getConcurrency() != ResultSet.CONCUR_READ_ONLY)
-		{
-			System.out.println("concurrency = " + rs.getConcurrency() +
-							   ", not " + ResultSet.CONCUR_READ_ONLY);
-		}
-
-		rs.close();
-		ps_f_u.close();
-
 		return passed;
 	}
 
@@ -1102,7 +1042,6 @@
 		CallableStatement	cs_i_r = null; // insensitive, read only
 		CallableStatement	cs_i_u = null; // insensitive, updatable
 		CallableStatement	cs_f_r = null; // forward only, read only
-		CallableStatement	cs_f_u = null; // forward only, updatable
 
 		cs_s_r = conn.prepareCall(
 								"values cast (? as Integer)",
@@ -1212,28 +1151,6 @@
 		}
 		conn.clearWarnings();
 		cs_f_r.close();	
-
-		cs_f_u = conn.prepareCall(
-								"values cast (? as Integer)",
-								ResultSet.TYPE_FORWARD_ONLY,
-								ResultSet.CONCUR_UPDATABLE);
-
-		// We should have gotten 1 warnings
-		warningCount = 0;
-		warning = conn.getWarnings();
-		while (warning != null)
-		{
-			System.out.println("warning = " + warning);
-			warning = warning.getNextWarning();
-			warningCount++;
-		}
-		if (warningCount != 1)
-		{
-			System.out.println("warningCount expected to be 1, not " + warningCount);
-			passed = false;
-		}
-		conn.clearWarnings();
-		cs_f_u.close();	
 
 		return passed;
 	}

Modified: incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/triggerGeneral.sql
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/triggerGeneral.sql?view=diff&rev=125266&p1=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/triggerGeneral.sql&r1=125265&p2=incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/triggerGeneral.sql&r2=125266
==============================================================================
--- incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/triggerGeneral.sql	(original)
+++ incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/triggerGeneral.sql	Sat Jan 15 08:13:54 2005
@@ -28,7 +28,7 @@
 -- make sure system tables look as we expect
 select cast(triggername as char(10)), event, firingtime, type, state, referencedcolumns from sys.systriggers;
 
-select cast(triggername as char(10)), text from sys.systriggers t, sys.sysstatements s 
+select cast(triggername as char(10)), CAST (TRIGGERDEFINITION AS VARCHAR(180)), STMTNAME from sys.systriggers t, sys.sysstatements s 
 		where s.stmtid = t.actionstmtid;
 
 select cast(triggername as char(10)), tablename from sys.systriggers t, sys.systables tb
@@ -411,19 +411,17 @@
 insert into trigtable values (1, 2, 3);
 create trigger "tt1" after insert on trigtable
 referencing NEW as NEW for each row mode db2sql
-insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values
-(new."cOlUmN1" + 5, "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", 5);
+insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values (new."cOlUmN1" + 5, "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", 5);
 maximumdisplaywidth 2000;
-select cast(triggername as char(10)), text from sys.systriggers t, sys.sysstatements s 
+select cast(triggername as char(10)), CAST (TRIGGERDEFINITION AS VARCHAR(180)), STMTNAME from sys.systriggers t, sys.sysstatements s 
 		where s.stmtid = t.actionstmtid and triggername = 'tt1';
 insert into trigtable values (1, 2, 3);
 select * from trighistory;
 drop trigger "tt1";
 create trigger "tt1" after insert on trigtable
 referencing new as new for each row mode db2sql
-insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values
-(new."cOlUmN1" + new."cOlUmN1", "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", new."cOlUmN2  " * 3);
-select cast(triggername as char(10)), text from sys.systriggers t, sys.sysstatements s 
+insert into trighistory ("cOlUmN1", "cOlUmN2  ", "cOlUmN3""""  ") values (new."cOlUmN1" + new."cOlUmN1", "NEW"."cOlUmN2  " * new."cOlUmN3""""  ", new."cOlUmN2  " * 3);
+select cast(triggername as char(10)), CAST (TRIGGERDEFINITION AS VARCHAR(180)), STMTNAME from sys.systriggers t, sys.sysstatements s 
 		where s.stmtid = t.actionstmtid and triggername = 'tt1';
 insert into trigtable values (1, 2, 3);
 select * from trighistory;

Added: incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/updatableResultSet.java
Url: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/updatableResultSet.java?view=auto&rev=125266
==============================================================================
--- (empty file)
+++ incubator/derby/code/trunk/java/testing/org/apache/derbyTesting/functionTests/tests/lang/updatableResultSet.java	Sat Jan 15 08:13:54 2005
@@ -0,0 +1,804 @@
+/*
+
+   Derby - Class org.apache.derbyTesting.functionTests.lang.updatableResultSet
+
+   Copyright 2004 The Apache Software Foundation or its licensors, as applicable.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+
+package org.apache.derbyTesting.functionTests.tests.lang;
+
+import java.sql.CallableStatement;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+
+import org.apache.derby.tools.ij;
+import org.apache.derby.tools.JDBCDisplayUtil;
+
+/**
+  This tests JDBC 2.0 updateable resutlset - deleteRow api
+ */
+public class updatableResultSet {
+
+	private static Connection conn;
+	private static DatabaseMetaData dbmt;
+	private static Statement stmt, stmt1;
+	private static ResultSet rs;
+	private static PreparedStatement pStmt = null;
+	private static CallableStatement callStmt = null;
+
+	public static void main(String[] args) {
+		System.out.println("Start testing delete using JDBC2.0 updateable resultset apis");
+
+		try {
+			// use the ij utility to read the property file and
+			// make the initial connection.
+			ij.getPropertyArg(args);
+			conn = ij.startJBMS();
+
+			setup(true);
+
+			System.out.println("---Negative Testl - request for scroll insensitive updatable resultset will give a read only scroll insensitive resultset");
+			conn.clearWarnings();
+			stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
+			SQLWarning warnings = conn.getWarnings();
+			while (warnings != null)
+			{
+				System.out.println("warnings on connection = " + warnings);
+				warnings = warnings.getNextWarning();
+			}
+			conn.clearWarnings();
+      System.out.println("requested TYPE_SCROLL_INSENSITIVE, CONCUR_UPDATABLE but that is not supported");
+      System.out.println("Make sure that we got TYPE_SCROLL_INSENSITIVE? " +  (stmt.getResultSetType() == ResultSet.TYPE_SCROLL_INSENSITIVE));
+      System.out.println("Make sure that we got CONCUR_READ_ONLY? " +  (stmt.getResultSetConcurrency() == ResultSet.CONCUR_READ_ONLY));
+			dbmt = conn.getMetaData();
+      System.out.println("ownDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE)? " + dbmt.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+      System.out.println("othersDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE)? " + dbmt.othersDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+      System.out.println("deletesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE)? " + dbmt.deletesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
+			System.out.println("JDBC 2.0 updatable resultset api will fail on this resultset because this is not an updatable resultset");
+      rs = stmt.executeQuery("SELECT * FROM t1 FOR UPDATE");
+			rs.next();
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because Derby does not yet support scroll insensitive updatable resultsets");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XJ083"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			rs.next();
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Negative Test2 - request for scroll sensitive updatable resultset will give a read only scroll insensitive resultset");
+			stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
+			while (warnings != null)
+			{
+				System.out.println("warnings on connection = " + warnings);
+				warnings = warnings.getNextWarning();
+			}
+			conn.clearWarnings();
+      System.out.println("requested TYPE_SCROLL_SENSITIVE, CONCUR_UPDATABLE but that is not supported");
+      System.out.println("Make sure that we got TYPE_SCROLL_INSENSITIVE? " +  (stmt.getResultSetType() == ResultSet.TYPE_SCROLL_INSENSITIVE));
+      System.out.println("Make sure that we got CONCUR_READ_ONLY? " +  (stmt.getResultSetConcurrency() == ResultSet.CONCUR_READ_ONLY));
+			System.out.println("JDBC 2.0 updatable resultset api will fail on this resultset because this is not an updatable resultset");
+      rs = stmt.executeQuery("SELECT * FROM t1 FOR UPDATE");
+			rs.next();
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because Derby does not yet support scroll sensitive updatable resultsets");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XJ083"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			rs.next();//make sure rs.next() does not fail because of earlier deleteRow
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Negative Test3 - request a read only resultset and attempt deleteRow on it");
+			stmt = conn.createStatement();//the default is a read only forward only resultset
+			rs = stmt.executeQuery("select * from t1");
+			System.out.println("Make sure that we got CONCUR_READ_ONLY? " + (rs.getConcurrency() == ResultSet.CONCUR_READ_ONLY));
+			rs.next();
+      System.out.println("Now attempting to send a deleteRow on a read only resultset.");
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because this is a read only resultset");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XJ083"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Negative Test4 - request a read only resultset and send a sql with FOR UPDATE clause and attempt deleteRow on it");
+			stmt = conn.createStatement();//the default is a read only forward only resultset
+			rs = stmt.executeQuery("select * from t1 FOR UPDATE");
+			System.out.println("Make sure that we got CONCUR_READ_ONLY? " + (rs.getConcurrency() == ResultSet.CONCUR_READ_ONLY));
+			rs.next();
+      System.out.println("Now attempting to send a deleteRow on a read only resultset with FOR UPDATE clause in the SELECT sql.");
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because this is a read only resultset");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XJ083"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Negative Test5 - request updatable resultset for sql with no FOR UPDATE clause");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+			rs = stmt.executeQuery("select * from t1");//notice that we forgot to give mandatory FOR UPDATE clause for updatable resultset
+			System.out.println("Make sure that we got CONCUR_READ_ONLY? " + (rs.getConcurrency() == ResultSet.CONCUR_READ_ONLY));
+			warnings = rs.getWarnings();
+			while (warnings != null)
+			{
+				System.out.println("Expected warnings on resultset = " + warnings);
+				warnings = warnings.getNextWarning();
+			}
+			rs.clearWarnings();
+			rs.next();
+      System.out.println("Now attempting to send a delete on a sql with no FOR UPDATE clause.");
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed on sql with no FOR UPDATE clause");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XJ083"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Negative Test6 - request updatable resultset for sql with FOR READ ONLY clause");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+			rs = stmt.executeQuery("select * from t1 FOR READ ONLY");
+			System.out.println("Make sure that we got CONCUR_READ_ONLY? " + (rs.getConcurrency() == ResultSet.CONCUR_READ_ONLY));
+			warnings = rs.getWarnings();
+			while (warnings != null)
+			{
+				System.out.println("Expected warnings on resultset = " + warnings);
+				warnings = warnings.getNextWarning();
+			}
+			rs.clearWarnings();
+			rs.next();
+      System.out.println("Now attempting to send a delete on a sql with FOR READ ONLY clause.");
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed on sql with FOR READ ONLY clause");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XJ083"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Negative Test7 - attempt to deleteRow on updatable resultset when the resultset is not positioned on a row");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE");
+			System.out.println("Make sure that we got CONCUR_UPDATABLE? " + (rs.getConcurrency() == ResultSet.CONCUR_UPDATABLE));
+      System.out.println("Now attempt a deleteRow without first doing next on the resultset.");
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because resultset is not on a row");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("24000"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			while (rs.next());//read all the rows from the resultset and position after the last row
+      System.out.println("ResultSet is positioned after the last row. attempt to deleteRow at this point should fail!");
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because resultset is after the last row");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("24000"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			rs.close();
+
+			System.out.println("---Negative Test8 - attempt deleteRow on updatable resultset after closing the resultset");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE");
+			System.out.println("Make sure that we got CONCUR_UPDATABLE? " + (rs.getConcurrency() == ResultSet.CONCUR_UPDATABLE));
+			rs.next();
+			rs.close();
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because resultset is closed");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XCL16"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+
+			System.out.println("---Negative Test9 - try updatable resultset on system table");
+			try {
+				rs = stmt.executeQuery("SELECT * FROM sys.systables FOR UPDATE");
+				System.out.println("FAIL!!! trying to open an updatable resultset on a system table should have failed because system tables can't be updated by a user");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("42Y90"))
+					System.out.println("expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+
+			System.out.println("---Negative Test10 - try updatable resultset on a view");
+			try {
+				rs = stmt.executeQuery("SELECT * FROM v1 FOR UPDATE");
+				System.out.println("FAIL!!! trying to open an updatable resultset on a view should have failed because Derby doesnot support updates to views yet");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("42Y90"))
+					System.out.println("expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			stmt.executeUpdate("drop view v1");
+
+			System.out.println("---Negative Test11 - attempt to open updatable resultset when there is join in the select query should fail");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+			try {
+				rs = stmt.executeQuery("SELECT c1 FROM t1,t2 where t1.c1 = t2.c21 FOR UPDATE");
+				System.out.println("FAIL!!! trying to open an updatable resultset should have failed because updatable resultset donot support join in the select query");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("42Y90"))
+					System.out.println("expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+
+			System.out.println("---Negative Test12 - With autocommit on, attempt to drop a table when there is an open updatable resultset on it");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE");
+			rs.next();
+			System.out.println("Opened an updatable resultset. Now trying to drop that table through another Statement");
+			stmt1 = conn.createStatement();
+			try {
+				stmt1.executeUpdate("drop table t1");
+				System.out.println("FAIL!!! drop table should have failed because the updatable resultset is still open");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("X0X95")) {
+					System.out.println("expected exception " + e.getMessage());
+				} else
+					dumpSQLExceptions(e);
+			}
+			System.out.println("Since autocommit is on, the drop table exception resulted in a runtime rollback causing updatable resultset object to close");
+			try {
+				rs.deleteRow();
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XCL16"))
+					System.out.println("expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+
+			System.out.println("---Negative Test13 - foreign key constraint failure will cause deleteRow to fail");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT 1, 2 FROM tableWithPrimaryKey FOR UPDATE");
+			rs.next();
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because it will cause foreign key constraint failure");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("23503"))
+					System.out.println("expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			System.out.println("Since autocommit is on, the constraint exception resulted in a runtime rollback causing updatable resultset object to close");
+			try {
+				rs.next();
+				System.out.println("FAIL!!! next should have failed because foreign key constraint failure resulted in a runtime rollback");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XCL16"))
+					System.out.println("expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+
+			System.out.println("---Positive Test1 - request updatable resultset for forward only type resultset");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+			warnings = conn.getWarnings();
+			while (warnings != null)
+			{
+				System.out.println("warnings = " + warnings);
+				warnings = warnings.getNextWarning();
+			}
+      System.out.println("requested TYPE_FORWARD_ONLY, CONCUR_UPDATABLE");
+      System.out.println("got TYPE_FORWARD_ONLY? " +  (stmt.getResultSetType() == ResultSet.TYPE_FORWARD_ONLY));
+      System.out.println("got CONCUR_UPDATABLE? " +  (stmt.getResultSetConcurrency() == ResultSet.CONCUR_UPDATABLE));
+      rs = stmt.executeQuery("SELECT * FROM t1 FOR UPDATE");
+			System.out.println("JDBC 2.0 updatable resultset apis on this ResultSet object will pass because this is an updatable resultset");
+			rs.next();
+      System.out.println("column 1 on this row before deleteRow is " + rs.getInt(1));
+      System.out.println("column 2 on this row before deleteRow is " + rs.getString(2));
+			rs.deleteRow();
+      System.out.println("Since after deleteRow(), ResultSet is positioned before the next row, getXXX will fail");
+			try {
+				System.out.println("column 1 on this deleted row is " + rs.getInt(1));
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("24000"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+      System.out.println("calling deleteRow again w/o first positioning the ResultSet on the next row will fail");
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because it can't be called more than once on the same row");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("24000"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+      System.out.println("Position the ResultSet with next()");
+			rs.next();
+      System.out.println("Should be able to deletRow() on the current row now");
+			rs.deleteRow();
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Positive Test2 - even if no columns from table specified in the column list, we should be able to get updatable resultset");
+      reloadData();
+      System.out.println("total number of rows in T1 ");
+      dumpRS(stmt.executeQuery("select count(*) from t1"));
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE");
+			rs.next();
+      System.out.println("column 1 on this row is " + rs.getInt(1));
+			rs.deleteRow();
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+      System.out.println("total number of rows in T1 after one deleteRow is ");
+      dumpRS(stmt.executeQuery("select count(*) from t1"));
+
+			System.out.println("---Positive Test3 - use prepared statement with concur updatable status");
+      reloadData();
+			pStmt = conn.prepareStatement("select * from t1 where c1>? for update", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      System.out.println("requested TYPE_FORWARD_ONLY, CONCUR_UPDATABLE");
+      System.out.println("got TYPE_FORWARD_ONLY? " +  (pStmt.getResultSetType() == ResultSet.TYPE_FORWARD_ONLY));
+      System.out.println("got CONCUR_UPDATABLE? " +  (pStmt.getResultSetConcurrency() == ResultSet.CONCUR_UPDATABLE));
+			pStmt.setInt(1,0);
+      rs = pStmt.executeQuery();
+			rs.next();
+      System.out.println("column 1 on this row is " + rs.getInt(1));
+			rs.deleteRow();
+      System.out.println("Since after deleteRow(), ResultSet is positioned before the next row, getXXX will fail");
+			try {
+				System.out.println("column 1 on this deleted row is " + rs.getInt(1));
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("24000"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+      System.out.println("calling deleteRow again w/o first positioning the ResultSet on the next row will fail");
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because it can't be called more than once on the same row");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("24000"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+      System.out.println("Position the ResultSet with next()");
+			rs.next();
+      System.out.println("Should be able to deletRow() on the current row now");
+			rs.deleteRow();
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Positive Test4 - use callable statement with concur updatable status");
+      reloadData();
+			callStmt = conn.prepareCall("select * from t1 for update", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = callStmt.executeQuery();
+      System.out.println("requested TYPE_FORWARD_ONLY, CONCUR_UPDATABLE");
+      System.out.println("got TYPE_FORWARD_ONLY? " +  (callStmt.getResultSetType() == ResultSet.TYPE_FORWARD_ONLY));
+      System.out.println("got CONCUR_UPDATABLE? " +  (callStmt.getResultSetConcurrency() == ResultSet.CONCUR_UPDATABLE));
+			rs.next();
+      System.out.println("row not deleted yet. Confirm with rs.rowDeleted()? " + rs.rowDeleted());
+      System.out.println("column 1 on this row is " + rs.getInt(1));
+			rs.deleteRow();
+      System.out.println("Since after deleteRow(), ResultSet is positioned before the next row, getXXX will fail");
+			try {
+				System.out.println("column 1 on this deleted row is " + rs.getInt(1));
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("24000"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+      System.out.println("calling deleteRow again w/o first positioning the ResultSet on the next row will fail");
+			try {
+				rs.deleteRow();
+				System.out.println("FAIL!!! deleteRow should have failed because it can't be called more than once on the same row");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("24000"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+      System.out.println("Position the ResultSet with next()");
+			rs.next();
+      System.out.println("Should be able to deletRow() on the current row now");
+			rs.deleteRow();
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Positive Test5 - donot have to select primary key to get an updatable resultset");
+      reloadData();
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT c32 FROM t3 FOR UPDATE");
+			rs.next();
+      System.out.println("column 1 on this row is " + rs.getInt(1));
+      System.out.println("now try to delete row when primary key is not selected for that row");
+			rs.deleteRow();
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Positive Test6 - For Forward Only resultsets, DatabaseMetaData will return false for ownDeletesAreVisible and deletesAreDetected");
+			System.out.println("---This is because, after deleteRow, we position the ResultSet before the next row. We don't make a hole for the deleted row and then stay on that deleted hole");
+			dbmt = conn.getMetaData();
+      System.out.println("ownDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY)? " + dbmt.ownDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+      System.out.println("othersDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY)? " + dbmt.othersDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+      System.out.println("deletesAreDetected(ResultSet.TYPE_FORWARD_ONLY)? " + dbmt.deletesAreDetected(ResultSet.TYPE_FORWARD_ONLY));
+      reloadData();
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE of c1");
+			rs.next();
+      System.out.println("The JDBC program should look at rowDeleted only if deletesAreDetected returns true");
+      System.out.println("Since Derby returns false for detlesAreDetected for FORWARD_ONLY updatable resultset,the program should not rely on rs.rowDeleted() for FORWARD_ONLY updatable resultsets");
+      System.out.println("Have this call to rs.rowDeleted() just to make sure the method does always return false? " + rs.rowDeleted());
+			rs.deleteRow();
+      System.out.println("Have this call to rs.rowDeleted() just to make sure the method does always return false? " + rs.rowDeleted());
+			rs.close();
+
+			System.out.println("---Positive Test7 - delete using updatable resultset api from a temporary table");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+			stmt.executeUpdate("DECLARE GLOBAL TEMPORARY TABLE SESSION.t2(c21 int, c22 int) on commit preserve rows not logged");
+			stmt.executeUpdate("insert into SESSION.t2 values(21, 1)");
+			stmt.executeUpdate("insert into SESSION.t2 values(22, 1)");
+			System.out.println("following rows in temp table before deleteRow");
+			dumpRS(stmt.executeQuery("select * from SESSION.t2"));
+			rs = stmt.executeQuery("select c21 from session.t2 for update");
+			rs.next();
+			rs.deleteRow();
+			rs.next();
+			rs.deleteRow();
+			System.out.println("As expected, no rows in temp table after deleteRow");
+			dumpRS(stmt.executeQuery("select * from SESSION.t2"));
+			rs.close();
+			stmt.executeUpdate("DROP TABLE SESSION.t2");
+
+			System.out.println("---Positive Test8 - change the name of the resultset and see if deleteRow still works");
+      reloadData();
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      System.out.println("change the cursor name(case sensitive name) with setCursorName and then try to deleteRow");
+			stmt.setCursorName("CURSORNOUPDATe");//notice this name is case sensitive
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE of c1");
+			rs.next();
+			rs.deleteRow();
+      System.out.println("change the cursor name one more time with setCursorName and then try to deleteRow");
+			stmt.setCursorName("CURSORNOUPDATE1");
+			rs.next();
+			rs.deleteRow();
+			rs.close();
+
+			System.out.println("---Positive Test9 - using correlation name for the table in the select sql is not a problem");
+      reloadData();
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 abcde FOR UPDATE of c1");
+			rs.next();
+      System.out.println("column 1 on this row is " + rs.getInt(1));
+      System.out.println("now try to deleteRow");
+			rs.deleteRow();
+			rs.close();
+
+			System.out.println("---Positive Test10 - 2 updatable resultsets going against the same table, will they conflict?");
+			conn.setAutoCommit(false);
+      reloadData();
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+			stmt1 = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE");
+			rs.next();
+      ResultSet rs1 = stmt1.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE");
+			rs1.next();
+			System.out.println("delete using first resultset");
+			rs.deleteRow();
+			try {
+				System.out.println("attempt to send deleteRow on the same row through a different resultset should throw an exception");
+				rs1.deleteRow();
+				System.out.println("FAIL!!! delete using second resultset succedded? " + rs1.rowDeleted());
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("XCL08"))
+					System.out.println("Got expected exception " + e.getMessage());
+				else
+					dumpSQLExceptions(e);
+			}
+			System.out.println("Move to next row in the 2nd resultset and then delete using the second resultset");
+			rs1.next();
+			rs1.deleteRow();
+			rs.close();
+			rs1.close();
+			conn.setAutoCommit(true);
+
+			System.out.println("---Positive Test11 - setting the fetch size to > 1 will be ignored by updatable resultset. Same as updatable cursors");
+      reloadData();
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+			stmt.executeUpdate("call SYSCS_UTIL.SYSCS_SET_RUNTIMESTATISTICS(1)");
+			stmt.setFetchSize(200);
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE of c1");
+			System.out.println("Notice the Fetch Size in run time statistics output.");
+      showScanStatistics(rs, conn);
+			System.out.println("statement's fetch size is " + stmt.getFetchSize());
+			rs.close();
+			stmt.executeUpdate("call SYSCS_UTIL.SYSCS_SET_RUNTIMESTATISTICS(0)");
+
+			System.out.println("---Positive Test12 - make sure delete trigger gets fired when deleteRow is issued");
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+			System.out.println("Verify that before delete trigger got fired, row count is 0 in deleteTriggerInsertIntoThisTable");
+			dumpRS(stmt.executeQuery("select count(*) from deleteTriggerInsertIntoThisTable"));
+			rs = stmt.executeQuery("SELECT * FROM tableWithDeleteTriggers FOR UPDATE");
+			rs.next();
+			System.out.println("column 1 on this row is " + rs.getInt(1));
+			System.out.println("now try to delete row and make sure that trigger got fired");
+			rs.deleteRow();
+			rs.close();
+			System.out.println("Verify that delete trigger got fired by verifying the row count to be 1 in deleteTriggerInsertIntoThisTable");
+			dumpRS(stmt.executeQuery("select count(*) from deleteTriggerInsertIntoThisTable"));
+			//have to close the resultset because by default, resultsets are held open over commit
+			rs.close();
+
+			System.out.println("---Positive Test13 - With autocommit off, attempt to drop a table when there is an open updatable resultset on it");
+      reloadData();
+      conn.setAutoCommit(false);
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT 1, 2 FROM t1 FOR UPDATE");
+			rs.next();
+			System.out.println("Opened an updatable resultset. Now trying to drop that table through another Statement");
+			stmt1 = conn.createStatement();
+			try {
+				stmt1.executeUpdate("drop table t1");
+				System.out.println("FAIL!!! drop table should have failed because the updatable resultset is still open");
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("X0X95")) {
+					System.out.println("expected exception " + e.getMessage());
+				} else
+					dumpSQLExceptions(e);
+			}
+			System.out.println("Since autocommit is off, the drop table exception will NOT result in a runtime rollback and hence updatable resultset object is still open");
+      rs.deleteRow();
+			rs.close();
+      conn.setAutoCommit(true);
+
+			System.out.println("---Positive Test14 - After deleteRow, resultset is positioned before the next row");
+      reloadData();
+			stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+      rs = stmt.executeQuery("SELECT * FROM t1 FOR UPDATE");
+			rs.next();
+			rs.deleteRow();
+      System.out.println("getXXX right after deleteRow will fail because resultset is not positioned on a row, instead it is right before the next row");
+			try {
+				System.out.println("column 1 (which is not nullable) after deleteRow is " + rs.getString(1));
+			}
+			catch (SQLException e) {
+				if (e.getSQLState().equals("24000")) {
+					System.out.println("expected exception " + e.getMessage());
+				} else
+					dumpSQLExceptions(e);
+			}
+			rs.close();
+
+			teardown();
+
+			conn.close();
+
+		} catch (Throwable e) {
+			System.out.println("FAIL: exception thrown:");
+			JDBCDisplayUtil.ShowException(System.out,e);
+		}
+
+		System.out.println("Finished testing updateable resultsets");
+	}
+
+	// lifted from the autoGeneratedJdbc30 test
+	public static void dumpRS(ResultSet s) throws SQLException
+	{
+		if (s == null)
+		{
+			System.out.println("<NULL>");
+			return;
+		}
+
+		ResultSetMetaData rsmd = s.getMetaData();
+
+		// Get the number of columns in the result set
+		int numCols = rsmd.getColumnCount();
+
+		if (numCols <= 0)
+		{
+			System.out.println("(no columns!)");
+			return;
+		}
+
+		StringBuffer heading = new StringBuffer("\t ");
+		StringBuffer underline = new StringBuffer("\t ");
+
+		int len;
+		// Display column headings
+		for (int i=1; i<=numCols; i++)
+		{
+			if (i > 1)
+			{
+				heading.append(",");
+				underline.append(" ");
+			}
+			len = heading.length();
+			heading.append(rsmd.getColumnLabel(i));
+			len = heading.length() - len;
+			for (int j = len; j > 0; j--)
+			{
+				underline.append("-");
+			}
+		}
+		System.out.println(heading.toString());
+		System.out.println(underline.toString());
+
+
+		StringBuffer row = new StringBuffer();
+		// Display data, fetching until end of the result set
+		while (s.next())
+		{
+			row.append("\t{");
+			// Loop through each column, getting the
+			// column data and displaying
+			for (int i=1; i<=numCols; i++)
+			{
+				if (i > 1) row.append(",");
+				row.append(s.getString(i));
+			}
+			row.append("}\n");
+		}
+		System.out.println(row.toString());
+		s.close();
+	}
+
+	static void reloadData() throws SQLException {
+		Statement stmt = conn.createStatement();
+		stmt.executeUpdate("delete from t1");
+		stmt.executeUpdate("insert into t1 values (1,'aa')");
+		stmt.executeUpdate("insert into t1 values (2,'bb')");
+		stmt.executeUpdate("insert into t1 values (3,'cc')");
+		stmt.executeUpdate("delete from t3");
+		stmt.executeUpdate("insert into t3 values (1,1)");
+		stmt.executeUpdate("insert into t3 values (2,2)");
+	}
+
+	static void setup(boolean first) throws SQLException {
+		Statement stmt = conn.createStatement();
+		stmt.executeUpdate("create table t1 (c1 int, c2 char(20))");
+		stmt.executeUpdate("create view v1 as select * from t1");
+		stmt.executeUpdate("create table t2 (c21 int, c22 int)");
+		stmt.executeUpdate("create table t3 (c31 int not null primary key, c32 smallint)");
+		stmt.executeUpdate("create table tableWithPrimaryKey (c1 int not null, c2 int not null, constraint pk primary key(c1,c2))");
+		stmt.executeUpdate("create table tableWithConstraint (c1 int, c2 int, constraint fk foreign key(c1,c2) references tableWithPrimaryKey)");
+		stmt.executeUpdate("create table tableWithDeleteTriggers (c1 int, c2 bigint)");
+		stmt.executeUpdate("create table deleteTriggerInsertIntoThisTable (c1 int)");
+		stmt.executeUpdate("create trigger tr1 after delete on tableWithDeleteTriggers for each statement mode db2sql insert into deleteTriggerInsertIntoThisTable values (1)");
+		stmt.executeUpdate("create table anotherTableWithDeleteTriggers (c1 int, c2 bigint)");
+		stmt.executeUpdate("create trigger tr2 after delete on anotherTableWithDeleteTriggers for each statement mode db2sql delete from anotherTableWithDeleteTriggers");
+
+		stmt.executeUpdate("insert into t1 values (1,'aa')");
+		stmt.executeUpdate("insert into t1 values (2,'bb')");
+		stmt.executeUpdate("insert into t1 values (3,'cc')");
+		stmt.executeUpdate("insert into t2 values (1,1)");
+		stmt.executeUpdate("insert into t3 values (1,1)");
+		stmt.executeUpdate("insert into t3 values (2,2)");
+		stmt.executeUpdate("insert into tableWithPrimaryKey values (1, 1), (2, 2), (3, 3), (4, 4)");
+		stmt.executeUpdate("insert into tableWithConstraint values (1, 1), (2, 2), (3, 3), (4, 4)");
+		stmt.executeUpdate("insert into tableWithDeleteTriggers values (1, 1), (2, 2), (3, 3), (4, 4)");
+		stmt.executeUpdate("insert into anotherTableWithDeleteTriggers values (1, 1), (2, 2), (3, 3), (4, 4)");
+		stmt.close();
+	}
+
+
+	static void teardown() throws SQLException {
+		Statement stmt = conn.createStatement();
+		stmt.executeUpdate("drop table t1");
+		stmt.executeUpdate("drop table t2");
+		stmt.executeUpdate("drop table t3");
+		stmt.executeUpdate("drop table tableWithConstraint");
+		stmt.executeUpdate("drop table tableWithPrimaryKey");
+		conn.commit();
+		stmt.close();
+	}
+
+	public static void showScanStatistics(ResultSet rs, Connection conn)
+	{
+		Statement s = null;
+		ResultSet infors = null;
+
+		
+		try {
+			rs.close(); // need to close to get statistics
+			s =conn.createStatement();
+			infors = s.executeQuery("values SYSCS_UTIL.SYSCS_GET_RUNTIMESTATISTICS()");
+			JDBCDisplayUtil.setMaxDisplayWidth(2000);
+			JDBCDisplayUtil.DisplayResults(System.out,infors,conn);
+			infors.close();
+		}
+		catch (SQLException se)
+		{
+			System.out.print("FAIL:");
+			JDBCDisplayUtil.ShowSQLException(System.out,se);
+		}			
+	}
+
+	static private void dumpSQLExceptions (SQLException se) {
+		System.out.println("FAIL -- unexpected exception: " + se.toString());
+		while (se != null) {
+			System.out.print("SQLSTATE("+se.getSQLState()+"):");
+			se = se.getNextException();
+		}
+	}
+
+}

Mime
View raw message