UpdatableResultSetTest (Apache Derby V10.10 Test Javadoc)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - org.apache.derbyTesting.junit.BaseTestCase
    - - org.apache.derbyTesting.junit.BaseJDBCTestCase
      - org.apache.derbyTesting.functionTests.tests.lang.UpdatableResultSetTest

All Implemented Interfaces:

junit.framework.Test
```
public class UpdatableResultSetTest
extends BaseJDBCTestCase
```
This tests JDBC 2.0 updateable resultset - deleteRow, updateRow, and insertRow API

Field Summary

Fields
Modifier and Type	Field and Description
`private static java.lang.String[]`	`allSQLTypes`
`private static java.lang.String[]`	`allUpdateXXXNames`
`private static java.lang.String[]`	`ColumnNames`
`private static java.lang.String[][]`	`SQLData`
`static java.lang.String[][]`	`updateObjectRulesTableForNetworkClient`
`static java.lang.String[][]`	`updateXXXRulesTableForEmbedded`
`static java.lang.String[][]`	`updateXXXRulesTableForNetworkClient`

Fields inherited from class org.apache.derbyTesting.junit.BaseTestCase
DEFAULT_DB_DIR, DERBY_LOG, ERRORSTACKTRACEFILE

Constructor Summary

Constructors
Constructor and Description

UpdatableResultSetTest(java.lang.String name)
Creates a new instance of UpdatableResultSetTest

Constructors
Constructor and Description
`UpdatableResultSetTest(java.lang.String name)` Creates a new instance of UpdatableResultSetTest

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private static junit.framework.TestSuite`	`baseSuite(java.lang.String name)`
`private void`	`createAllDatatypesTable()`
`private void`	`createSelfReferencingTable()`
`private void`	`createTable0WithTrigger()`
`private void`	`createTable1WithTrigger()`
`private void`	`createTableT1()`
`private void`	`createTableT2()`
`private void`	`createTableT3()`
`private void`	`createTableT4()`
`private void`	`createTableT5()`
`private void`	`createTableWithPrimaryKey()`
`private void`	`resetData()`
`private void`	`runTestUpdateObjectWithAllDatatypes(java.sql.PreparedStatement pstmt, java.sql.PreparedStatement pstmt1, int sqlType, int updateXXXName)`
`private void`	`runTestUpdateXXXAllDataTypesInsertRow(java.sql.PreparedStatement pstmt, java.sql.PreparedStatement pstmt1, int sqlType, int updateXXXName)`
`private void`	`runTestUpdateXXXWithAllDatatypes(java.sql.PreparedStatement pstmt, java.sql.PreparedStatement pstmt1, int sqlType, int updateXXXName)`
`protected void`	`setUp()`
`static junit.framework.Test`	`suite()`
`void`	`testCallableStatementWithUpdatableResultSet()` Positive test - use callable statement with concur updatable status
`void`	`testCancelRowUpdatesAndDeleteRow()` Positive test - after updateXXX, try cancelRowUpdates and then deleteRow
`void`	`testCancelRowUpdatesOnReadOnlyRS()` Positive test - Test cancelRowUpdates method as the first updatable ResultSet api on a read-only resultset
`void`	`testCancelRowUpdatesWithoutUpdateXXX()` Positive test - issue cancelRowUpdates without any updateXXX
`void`	`testCaseSensitiveTableAndColumnName()` Positive test - case sensitive table and column names
`void`	`testDeleteRowAndRollbackWithTriggers()` Positive test - Do deleteRow within a transaction and then rollback the transaction
`void`	`testDeleteRowOnTempTable()` Positive test - delete using updatable resultset api from a temporary table
`void`	`testDeleteRowSelfReferential()` Positive test - make sure self referential delete cascade works when deleteRow is issued
`void`	`testDeleteRowWithCorrelationForColumnName()` Positive Test9b - using correlation name for updatable columns is not allowed.
`void`	`testDeleteRowWithCorrelationForTableName()` Positive test - using correlation name for the table in the select sql
`void`	`testDeleteRowWithDeleteTrigger()` Positive test - make sure delete trigger gets fired when deleteRow is issued
`void`	`testDeleteRowWithPreparedStatement()` Positive test - use prepared statement with concur updatable status to test deleteRow
`void`	`testDeleteRowWithSetCursorName()` Positive test - change the name of the statement when the resultset is open and see if deleteRow still works This test works in embedded mode since Derby can handle the change in the name of the statement with an open resultset But it fails under Network Server mode because JCC and Derby Net Client do not allow statement name change when there an open resultset against it
`void`	`testDeleteRowWithTriggerChangingRS()` Positive test - Another test case for delete trigger
`void`	`testDropTableWithUpatableResultSet()` Negative test - With autocommit on, attempt to drop a table when there is an open updatable resultset on it
`void`	`testDropTableWithUpdatableCursorOnIt()` Positive test - With autocommit off, attempt to drop a table when there is an open updatable resultset on it
`void`	`testForeignKeyConstraintFailureOnDeleteRow()` Negative test - foreign key constraint failure will cause deleteRow to fail
`void`	`testForeignKeyConstraintFailureOnUpdateRow()` Negative test - foreign key constraint failure will cause updateRow to fail
`void`	`testInsertRow()` Positive test - moveToInsertRow, insertRow, getXXX and moveToCurrentRow
`void`	`testInsertRowAfterClose()` Negative test - test insertRow on closed resultset
`void`	`testInsertRowFromCurrentRow()` Negative test - Try to insertRow from current row
`void`	`testInsertRowFromDifferentPositions()` Positive test - try insertRow from different positions
`void`	`testInsertRowReadOnlyRS()` Negative test - insertRow and read-only RS
`void`	`testInsertRowWithDefaultValue()` Positive test - try to insert without updating all columns.
`void`	`testInsertRowWithNullColumn()` Positive test - InsertRow leaving a nullable columns = NULL
`void`	`testMultipleUpdateXXXAndUpdateRow()` Positive test - issue multiple updateXXXs and then a updateRow
`void`	`testPositionedDeleteOnUpdatableResultSet()` Positive test - use updatable resultset to do postitioned delete
`void`	`testPositionedUpdateOnUpdatableResultSet()` Positive test - updatable resultset to do positioned update
`void`	`testResultSetNotPositionedAfterDeleteRow()` Positive test - request updatable resultset for forward only type resultset
`void`	`testResultSetNotPositionedAfterUpdateRow()` Positive test - request updatable resultset for forward only type resultset
`void`	`testResultSetPositionedBeforeNextAfterDeleteRow()` Positive test - After deleteRow, resultset is positioned before the next row
`void`	`testRollbackWithAutoCommit()` Positive test - Rollback with AutoCommit on
`void`	`testRowDeleted()` Positive test - 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.
`void`	`testRowUpdated()` Positive test - For Forward Only resultsets, DatabaseMetaData will return false for ownUpdatesAreVisible and updatesAreDetected This is because, after updateRow, we position the ResultSet before the next row
`void`	`testScrollSensitiveResultSet()` Negative test - request for scroll sensitive updatable resultset will give an updatable scroll insensitive resultset
`void`	`testSetFetchSizeOnUpdatableResultSet()` Positive test - setting the fetch size to > 1 will be ignored by updatable resultset.
`void`	`testTableAndColumnNameWithSpaces()` Positive test - table and column names with spaces in middle and end
`void`	`testTwoResultSetsDeletingSameRow()` Positive test - 2 updatable resultsets going against the same table
`void`	`testUpdatableResultsetNoColumnInColumnList()` Positive Test2 - even if no columns from table specified in the column list, we should be able to get updatable resultset
`void`	`testUpdatableResultSetOnJoin()` Negative test - attempt to open updatable resultset when there is join in the select query should fail
`void`	`testUpdatableResultSetOnSysTable()` Negative test - try updatable resultset on system table
`void`	`testUpdatableResultSetOnView()` Negative test - try updatable resultset on a view
`void`	`testUpdatableResultSetWithoutSelectingPrimaryKey()` Positive test - donot have to select primary key to get an updatable resultset
`void`	`testUpdateDeleteRowNotOnRow()` Negative test - attempt to deleteRow & updateRow on updatable resultset when the resultset is not positioned on a row
`void`	`testUpdateDeleteRowOnClosedResultSet()` Negative test - attempt deleteRow & updateRow on updatable resultset after closing the resultset
`void`	`testUpdateDeleteRowOnReadOnlyResultSet()` Negative test - request a read only resultset and attempt deleteRow and updateRow on it
`void`	`testUpdateDeleteRowOnReadOnlyResultSetWithForUpdate()` Negative Test - request a read only resultset and send a sql with FOR UPDATE clause and attempt deleteRow/updateRow on it
`void`	`testUpdateDeleteRowOnReadOnlyResultSetWithoutForUpdate()` Negative Test - request resultset with no FOR UPDATE clause and CONCUR_READ_ONLY
`void`	`testUpdateDeleteRowOnUpdatableResultSetWithForReadOnly()` Negative Test - request updatable resultset for sql with FOR READ ONLY clause
`void`	`testUpdateObjectWithAllDatatypes()` Positive test - Test updateObject method
`void`	`testUpdateRowAndRollbackWithTriggers()` Positive test - Do updateRow within a transaction and then rollback the transaction
`void`	`testUpdateRowDeleteRowDoNotCommit()` Positive test - in autocommit mode, check that updateRow and deleteRow does not commit
`void`	`testUpdateRowDeleteRowFromInsertRow()` Negative test - run updateRow and deleterow when positioned at insertRow
`void`	`testUpdateRowOnReadOnlyRS()` Positive test - Test updateRow method as the first updatable ResultSet api on a read-only resultset
`void`	`testUpdateRowOnTempTable()` Positive test - update using updatable resultset api from a temporary table
`void`	`testUpdateRowSelfReferential()` Positive test - make sure self referential update restrict works when updateRow is issued
`void`	`testUpdateRowWithCorrelationOnTableAndColumn()` Positive test - try to get an updatable resultset using correlation name for a readonly column
`void`	`testUpdateRowWithoutUpdateXXX()` Positive test - issue updateRow without any updateXXX will not move the resultset position
`void`	`testUpdateRowWithSetCursorName()` Positive test - change the name of the statement when the resultset is open and see if updateRow still works This test works in embedded mode since Derby can handle the change in the name of the statement with an open resultset But it fails under Network Server mode because JCC and Derby Net Client do not allow statement name change when there an open resultset against it
`void`	`testUpdateRowWithTriggerChangingRS()` Positive test - Another test case for update trigger
`void`	`testUpdateRowWithUpdateTrigger()` Positive test - make sure that update trigger gets fired when updateRow is issue
`void`	`testUpdateTableDifferentSchema()` Positive test - try to update a table from another schema
`void`	`testUpdateXXXAllDataTypesInsertRow()` Positive test - Test all updateXXX methods on all the supported sql datatypes
`void`	`testUpdateXXXAndDeleteRow()` Positive test - issue updateXXX and then deleteRow
`void`	`testUpdateXXXAndMoveNext()` Positive test - issue updateXXXs and then move off the row, the changes should be ignored
`void`	`testUpdateXXXNotForUpdateColumns()` Positive test - call updateXXX methods on column that is not in for update columns list
`void`	`testUpdateXXXOnColumnNotFromTable()` Negative test - Can't call updateXXX methods on columns that do not correspond to a column in the table
`void`	`testUpdateXXXOnOutOfRangeColumn()` Negative test - Call updateXXX method on out of the range column
`void`	`testUpdateXXXOnReadOnlyColumn()` Positive test - try to updateXXX on a readonly column.
`void`	`testUpdateXXXOnReadOnlyColumnWithCorrelationName()` Positive test - try to updateXXX on a readonly column with correlation name.
`void`	`testUpdateXXXOnReadOnlyRS()` Positive test - Test updateXXX methods as the first updatable ResultSet api on a read-only resultset
`void`	`testUpdateXXXOnTableColumn()` Positive test - call updateXXX methods on only columns that correspond to a column in the table
`void`	`testUpdateXXXWithAllDatatypes()` Positive test - Test all updateXXX(excluding updateObject) methods on all the supported sql datatypes
`void`	`testUpdateXXXWithCancelRowUpdates()` Positive test - Test cancelRowUpdates after updateXXX methods on all the supported sql datatypes
`void`	`testUpdateXXXWithPreparedStatement()` Positive test - use prepared statement with concur updatable status to test updateXXX
`private void`	`verifyData(int sqlType, int updateXXXName)`
`void`	`xTestInsertRowAfterCommit()` Positive and negative tests - Commit while on insertRow

Methods inherited from class org.apache.derbyTesting.junit.BaseJDBCTestCase
assertCallError, assertCheckTable, assertCompileError, assertEquals, assertEquals, assertEquals, assertEquivalentDataType, assertErrorCode, assertGetIntError, assertNextError, assertPreparedStatementError, assertSQLExceptionEquals, assertSQLState, assertSQLState, assertStatementError, assertStatementError, assertStatementError, assertStatementError, assertStatementErrorUnordered, assertTableRowCount, assertUpdateCount, assertUpdateCount, assertWarning, checkAllConsistency, checkEstimatedRowCount, closeStatement, commit, createStatement, createStatement, createStatement, dropTable, dropTable, dropView, dropView, emptyStatementCache, getClientTransactionID, getConnection, getDatabaseProperty, getLastSQLException, initializeConnection, openConnection, openDefaultConnection, openDefaultConnection, openDefaultConnection, openUserConnection, prepareCall, prepareCall, prepareCall, prepareStatement, prepareStatement, prepareStatement, prepareStatement, prepareStatement, prepareStatement, rollback, runBare, runBareOverridable, runScript, runScript, runSQLCommands, setAutoCommit, tearDown, usingDB2Client, usingDerbyNetClient, usingEmbedded

Methods inherited from class org.apache.derbyTesting.junit.BaseTestCase
alarm, assertDirectoryDeleted, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertExecJavaCmdAsExpected, assertLaunchedJUnitTestMethod, assertLaunchedJUnitTestMethod, assertSecurityManager, assertThrowableEquals, currentDirectory, execJavaCmd, execJavaCmd, fail, getClassVersionMajor, getEmmaJar, getFailureFolder, getFilesWith, getJavaExecutableName, getSystemProperty, getTestConfiguration, getTestResource, hasInterruptibleIO, isCVM, isIBMJVM, isJ9Platform, isJava5, isJava7, isJava8, isPhoneME, isPlatform, isSunJVM, isWindowsPlatform, openTestResource, println, printStackTrace, readProcessOutput, removeDirectory, removeDirectory, removeFiles, removeSystemProperty, runsWithEmma, runsWithJaCoCo, setSystemProperty, sleep, sleepAtLeastOneTick, traceit

Methods inherited from class junit.framework.TestCase
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, countTestCases, createResult, fail, fail, failNotEquals, failNotSame, failSame, format, getName, run, run, runTest, setName, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - allUpdateXXXNames
```
private static java.lang.String[] allUpdateXXXNames
```
  - allSQLTypes
```
private static java.lang.String[] allSQLTypes
```
  - ColumnNames
```
private static java.lang.String[] ColumnNames
```
  - SQLData
```
private static java.lang.String[][] SQLData
```
  - updateXXXRulesTableForEmbedded
```
public static final java.lang.String[][] updateXXXRulesTableForEmbedded
```
  - updateXXXRulesTableForNetworkClient
```
public static final java.lang.String[][] updateXXXRulesTableForNetworkClient
```
  - updateObjectRulesTableForNetworkClient
```
public static final java.lang.String[][] updateObjectRulesTableForNetworkClient
```
- Constructor Detail
  - UpdatableResultSetTest
```
public UpdatableResultSetTest(java.lang.String name)
```
    Creates a new instance of UpdatableResultSetTest
- Method Detail
  - suite
```
public static junit.framework.Test suite()
```
  - baseSuite
```
private static junit.framework.TestSuite baseSuite(java.lang.String name)
```
  - setUp
```
protected void setUp()
              throws java.sql.SQLException
```
    Overrides:
    
    setUp in class junit.framework.TestCase
    
    Throws:
    
    java.sql.SQLException
  - testScrollSensitiveResultSet
```
public void testScrollSensitiveResultSet()
                                  throws java.sql.SQLException
```
    Negative test - request for scroll sensitive updatable resultset will give an updatable scroll insensitive resultset
    
    Throws:
    
    java.sql.SQLException
  - testUpdateDeleteRowOnReadOnlyResultSet
```
public void testUpdateDeleteRowOnReadOnlyResultSet()
                                            throws java.sql.SQLException
```
    Negative test - request a read only resultset and attempt deleteRow and updateRow on it
    
    Throws:
    
    java.sql.SQLException
  - testUpdateDeleteRowOnReadOnlyResultSetWithForUpdate
```
public void testUpdateDeleteRowOnReadOnlyResultSetWithForUpdate()
                                                         throws java.sql.SQLException
```
    Negative Test - request a read only resultset and send a sql with FOR UPDATE clause and attempt deleteRow/updateRow on it
    
    Throws:
    
    java.sql.SQLException
  - testUpdateDeleteRowOnReadOnlyResultSetWithoutForUpdate
```
public void testUpdateDeleteRowOnReadOnlyResultSetWithoutForUpdate()
                                                            throws java.sql.SQLException
```
    Negative Test - request resultset with no FOR UPDATE clause and CONCUR_READ_ONLY
    
    Throws:
    
    java.sql.SQLException
  - testUpdateDeleteRowOnUpdatableResultSetWithForReadOnly
```
public void testUpdateDeleteRowOnUpdatableResultSetWithForReadOnly()
                                                            throws java.sql.SQLException
```
    Negative Test - request updatable resultset for sql with FOR READ ONLY clause
    
    Throws:
    
    java.sql.SQLException
  - testUpdateDeleteRowNotOnRow
```
public void testUpdateDeleteRowNotOnRow()
                                 throws java.sql.SQLException
```
    Negative test - attempt to deleteRow & updateRow on updatable resultset when the resultset is not positioned on a row
    
    Throws:
    
    java.sql.SQLException
  - testUpdateDeleteRowOnClosedResultSet
```
public void testUpdateDeleteRowOnClosedResultSet()
                                          throws java.sql.SQLException
```
    Negative test - attempt deleteRow & updateRow on updatable resultset after closing the resultset
    
    Throws:
    
    java.sql.SQLException
  - testUpdatableResultSetOnSysTable
```
public void testUpdatableResultSetOnSysTable()
                                      throws java.sql.SQLException
```
    Negative test - try updatable resultset on system table
    
    Throws:
    
    java.sql.SQLException
  - testUpdatableResultSetOnView
```
public void testUpdatableResultSetOnView()
                                  throws java.sql.SQLException
```
    Negative test - try updatable resultset on a view
    
    Throws:
    
    java.sql.SQLException
  - testUpdatableResultSetOnJoin
```
public void testUpdatableResultSetOnJoin()
                                  throws java.sql.SQLException
```
    Negative test - attempt to open updatable resultset when there is join in the select query should fail
    
    Throws:
    
    java.sql.SQLException
  - testDropTableWithUpatableResultSet
```
public void testDropTableWithUpatableResultSet()
                                        throws java.sql.SQLException
```
    Negative test - With autocommit on, attempt to drop a table when there is an open updatable resultset on it
    
    Throws:
    
    java.sql.SQLException
  - testForeignKeyConstraintFailureOnDeleteRow
```
public void testForeignKeyConstraintFailureOnDeleteRow()
                                                throws java.sql.SQLException
```
    Negative test - foreign key constraint failure will cause deleteRow to fail
    
    Throws:
    
    java.sql.SQLException
  - testForeignKeyConstraintFailureOnUpdateRow
```
public void testForeignKeyConstraintFailureOnUpdateRow()
                                                throws java.sql.SQLException
```
    Negative test - foreign key constraint failure will cause updateRow to fail
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXOnColumnNotFromTable
```
public void testUpdateXXXOnColumnNotFromTable()
                                       throws java.sql.SQLException
```
    Negative test - Can't call updateXXX methods on columns that do not correspond to a column in the table
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXOnOutOfRangeColumn
```
public void testUpdateXXXOnOutOfRangeColumn()
                                     throws java.sql.SQLException
```
    Negative test - Call updateXXX method on out of the range column
    
    Throws:
    
    java.sql.SQLException
  - testResultSetNotPositionedAfterDeleteRow
```
public void testResultSetNotPositionedAfterDeleteRow()
                                              throws java.sql.SQLException
```
    Positive test - request updatable resultset for forward only type resultset
    
    Throws:
    
    java.sql.SQLException
  - testResultSetNotPositionedAfterUpdateRow
```
public void testResultSetNotPositionedAfterUpdateRow()
                                              throws java.sql.SQLException
```
    Positive test - request updatable resultset for forward only type resultset
    
    Throws:
    
    java.sql.SQLException
  - testPositionedDeleteOnUpdatableResultSet
```
public void testPositionedDeleteOnUpdatableResultSet()
                                              throws java.sql.SQLException
```
    Positive test - use updatable resultset to do postitioned delete
    
    Throws:
    
    java.sql.SQLException
  - testPositionedUpdateOnUpdatableResultSet
```
public void testPositionedUpdateOnUpdatableResultSet()
                                              throws java.sql.SQLException
```
    Positive test - updatable resultset to do positioned update
    
    Throws:
    
    java.sql.SQLException
  - testUpdatableResultsetNoColumnInColumnList
```
public void testUpdatableResultsetNoColumnInColumnList()
                                                throws java.sql.SQLException
```
    Positive Test2 - even if no columns from table specified in the column list, we should be able to get updatable resultset
    
    Throws:
    
    java.sql.SQLException
  - testDeleteRowWithPreparedStatement
```
public void testDeleteRowWithPreparedStatement()
                                        throws java.sql.SQLException
```
    Positive test - use prepared statement with concur updatable status to test deleteRow
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXWithPreparedStatement
```
public void testUpdateXXXWithPreparedStatement()
                                        throws java.sql.SQLException
```
    Positive test - use prepared statement with concur updatable status to test updateXXX
    
    Throws:
    
    java.sql.SQLException
  - testCallableStatementWithUpdatableResultSet
```
public void testCallableStatementWithUpdatableResultSet()
                                                 throws java.sql.SQLException
```
    Positive test - use callable statement with concur updatable status
    
    Throws:
    
    java.sql.SQLException
  - testUpdatableResultSetWithoutSelectingPrimaryKey
```
public void testUpdatableResultSetWithoutSelectingPrimaryKey()
                                                      throws java.sql.SQLException
```
    Positive test - donot have to select primary key to get an updatable resultset
    
    Throws:
    
    java.sql.SQLException
  - testRowDeleted
```
public void testRowDeleted()
                    throws java.sql.SQLException
```
    Positive test - 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
    
    Throws:
    
    java.sql.SQLException
  - testRowUpdated
```
public void testRowUpdated()
                    throws java.sql.SQLException
```
    Positive test - For Forward Only resultsets, DatabaseMetaData will return false for ownUpdatesAreVisible and updatesAreDetected This is because, after updateRow, we position the ResultSet before the next row
    
    Throws:
    
    java.sql.SQLException
  - testDeleteRowOnTempTable
```
public void testDeleteRowOnTempTable()
                              throws java.sql.SQLException
```
    Positive test - delete using updatable resultset api from a temporary table
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowOnTempTable
```
public void testUpdateRowOnTempTable()
                              throws java.sql.SQLException
```
    Positive test - update using updatable resultset api from a temporary table
    
    Throws:
    
    java.sql.SQLException
  - testDeleteRowWithSetCursorName
```
public void testDeleteRowWithSetCursorName()
                                    throws java.sql.SQLException
```
    Positive test - change the name of the statement when the resultset is open and see if deleteRow still works This test works in embedded mode since Derby can handle the change in the name of the statement with an open resultset But it fails under Network Server mode because JCC and Derby Net Client do not allow statement name change when there an open resultset against it
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowWithSetCursorName
```
public void testUpdateRowWithSetCursorName()
                                    throws java.sql.SQLException
```
    Positive test - change the name of the statement when the resultset is open and see if updateRow still works This test works in embedded mode since Derby can handle the change in the name of the statement with an open resultset But it fails under Network Server mode because JCC and Derby Net Client do not allow statement name change when there an open resultset against it
    
    Throws:
    
    java.sql.SQLException
  - testDeleteRowWithCorrelationForTableName
```
public void testDeleteRowWithCorrelationForTableName()
                                              throws java.sql.SQLException
```
    Positive test - using correlation name for the table in the select sql
    
    Throws:
    
    java.sql.SQLException
  - testDeleteRowWithCorrelationForColumnName
```
public void testDeleteRowWithCorrelationForColumnName()
                                               throws java.sql.SQLException
```
    Positive Test9b - using correlation name for updatable columns is not allowed.
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXOnReadOnlyColumn
```
public void testUpdateXXXOnReadOnlyColumn()
                                   throws java.sql.SQLException
```
    Positive test - try to updateXXX on a readonly column. Should get error
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowWithCorrelationOnTableAndColumn
```
public void testUpdateRowWithCorrelationOnTableAndColumn()
                                                  throws java.sql.SQLException
```
    Positive test - try to get an updatable resultset using correlation name for a readonly column
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXOnReadOnlyColumnWithCorrelationName
```
public void testUpdateXXXOnReadOnlyColumnWithCorrelationName()
                                                      throws java.sql.SQLException
```
    Positive test - try to updateXXX on a readonly column with correlation name. Should get error
    
    Throws:
    
    java.sql.SQLException
  - testTwoResultSetsDeletingSameRow
```
public void testTwoResultSetsDeletingSameRow()
                                      throws java.sql.SQLException
```
    Positive test - 2 updatable resultsets going against the same table
    
    Throws:
    
    java.sql.SQLException
  - testSetFetchSizeOnUpdatableResultSet
```
public void testSetFetchSizeOnUpdatableResultSet()
                                          throws java.sql.SQLException
```
    Positive test - setting the fetch size to > 1 will be ignored by updatable resultset. Same as updatable cursors
    
    Throws:
    
    java.sql.SQLException
  - testDeleteRowWithDeleteTrigger
```
public void testDeleteRowWithDeleteTrigger()
                                    throws java.sql.SQLException
```
    Positive test - make sure delete trigger gets fired when deleteRow is issued
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowWithUpdateTrigger
```
public void testUpdateRowWithUpdateTrigger()
                                    throws java.sql.SQLException
```
    Positive test - make sure that update trigger gets fired when updateRow is issue
    
    Throws:
    
    java.sql.SQLException
  - testDeleteRowWithTriggerChangingRS
```
public void testDeleteRowWithTriggerChangingRS()
                                        throws java.sql.SQLException
```
    Positive test - Another test case for delete trigger
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowWithTriggerChangingRS
```
public void testUpdateRowWithTriggerChangingRS()
                                        throws java.sql.SQLException
```
    Positive test - Another test case for update trigger
    
    Throws:
    
    java.sql.SQLException
  - testDeleteRowSelfReferential
```
public void testDeleteRowSelfReferential()
                                  throws java.sql.SQLException
```
    Positive test - make sure self referential delete cascade works when deleteRow is issued
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowSelfReferential
```
public void testUpdateRowSelfReferential()
                                  throws java.sql.SQLException
```
    Positive test - make sure self referential update restrict works when updateRow is issued
    
    Throws:
    
    java.sql.SQLException
  - testDropTableWithUpdatableCursorOnIt
```
public void testDropTableWithUpdatableCursorOnIt()
                                          throws java.sql.SQLException
```
    Positive test - With autocommit off, attempt to drop a table when there is an open updatable resultset on it
    
    Throws:
    
    java.sql.SQLException
  - testDeleteRowAndRollbackWithTriggers
```
public void testDeleteRowAndRollbackWithTriggers()
                                          throws java.sql.SQLException
```
    Positive test - Do deleteRow within a transaction and then rollback the transaction
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowAndRollbackWithTriggers
```
public void testUpdateRowAndRollbackWithTriggers()
                                          throws java.sql.SQLException
```
    Positive test - Do updateRow within a transaction and then rollback the transaction
    
    Throws:
    
    java.sql.SQLException
  - testResultSetPositionedBeforeNextAfterDeleteRow
```
public void testResultSetPositionedBeforeNextAfterDeleteRow()
                                                     throws java.sql.SQLException
```
    Positive test - After deleteRow, resultset is positioned before the next row
    
    Throws:
    
    java.sql.SQLException
  - testCancelRowUpdatesOnReadOnlyRS
```
public void testCancelRowUpdatesOnReadOnlyRS()
                                      throws java.sql.SQLException
```
    Positive test - Test cancelRowUpdates method as the first updatable ResultSet api on a read-only resultset
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowOnReadOnlyRS
```
public void testUpdateRowOnReadOnlyRS()
                               throws java.sql.SQLException
```
    Positive test - Test updateRow method as the first updatable ResultSet api on a read-only resultset
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXOnReadOnlyRS
```
public void testUpdateXXXOnReadOnlyRS()
                               throws java.sql.SQLException
```
    Positive test - Test updateXXX methods as the first updatable ResultSet api on a read-only resultset
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXWithAllDatatypes
```
public void testUpdateXXXWithAllDatatypes()
                                   throws java.sql.SQLException,
                                          java.lang.IllegalArgumentException,
                                          java.io.UnsupportedEncodingException
```
    Positive test - Test all updateXXX(excluding updateObject) methods on all the supported sql datatypes
    
    Throws:
    
    java.sql.SQLException
    
    java.lang.IllegalArgumentException
    
    java.io.UnsupportedEncodingException
  - runTestUpdateXXXWithAllDatatypes
```
private void runTestUpdateXXXWithAllDatatypes(java.sql.PreparedStatement pstmt,
                                              java.sql.PreparedStatement pstmt1,
                                              int sqlType,
                                              int updateXXXName)
                                       throws java.sql.SQLException,
                                              java.lang.IllegalArgumentException,
                                              java.io.UnsupportedEncodingException
```
    Throws:
    
    java.sql.SQLException
    
    java.lang.IllegalArgumentException
    
    java.io.UnsupportedEncodingException
  - testUpdateObjectWithAllDatatypes
```
public void testUpdateObjectWithAllDatatypes()
                                      throws java.sql.SQLException,
                                             java.lang.IllegalArgumentException,
                                             java.io.UnsupportedEncodingException
```
    Positive test - Test updateObject method
    
    Throws:
    
    java.sql.SQLException
    
    java.lang.IllegalArgumentException
    
    java.io.UnsupportedEncodingException
  - runTestUpdateObjectWithAllDatatypes
```
private void runTestUpdateObjectWithAllDatatypes(java.sql.PreparedStatement pstmt,
                                                 java.sql.PreparedStatement pstmt1,
                                                 int sqlType,
                                                 int updateXXXName)
                                          throws java.sql.SQLException,
                                                 java.lang.IllegalArgumentException,
                                                 java.io.UnsupportedEncodingException
```
    Throws:
    
    java.sql.SQLException
    
    java.lang.IllegalArgumentException
    
    java.io.UnsupportedEncodingException
  - testUpdateXXXWithCancelRowUpdates
```
public void testUpdateXXXWithCancelRowUpdates()
                                       throws java.sql.SQLException
```
    Positive test - Test cancelRowUpdates after updateXXX methods on all the supported sql datatypes
    
    Throws:
    
    java.sql.SQLException
  - testCancelRowUpdatesAndDeleteRow
```
public void testCancelRowUpdatesAndDeleteRow()
                                      throws java.sql.SQLException
```
    Positive test - after updateXXX, try cancelRowUpdates and then deleteRow
    
    Throws:
    
    java.sql.SQLException
  - testCancelRowUpdatesWithoutUpdateXXX
```
public void testCancelRowUpdatesWithoutUpdateXXX()
                                          throws java.sql.SQLException
```
    Positive test - issue cancelRowUpdates without any updateXXX
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowWithoutUpdateXXX
```
public void testUpdateRowWithoutUpdateXXX()
                                   throws java.sql.SQLException
```
    Positive test - issue updateRow without any updateXXX will not move the resultset position
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXAndDeleteRow
```
public void testUpdateXXXAndDeleteRow()
                               throws java.sql.SQLException
```
    Positive test - issue updateXXX and then deleteRow
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXAndMoveNext
```
public void testUpdateXXXAndMoveNext()
                              throws java.sql.SQLException
```
    Positive test - issue updateXXXs and then move off the row, the changes should be ignored
    
    Throws:
    
    java.sql.SQLException
  - testMultipleUpdateXXXAndUpdateRow
```
public void testMultipleUpdateXXXAndUpdateRow()
                                       throws java.sql.SQLException
```
    Positive test - issue multiple updateXXXs and then a updateRow
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXOnTableColumn
```
public void testUpdateXXXOnTableColumn()
                                throws java.sql.SQLException
```
    Positive test - call updateXXX methods on only columns that correspond to a column in the table
    
    Throws:
    
    java.sql.SQLException
  - testCaseSensitiveTableAndColumnName
```
public void testCaseSensitiveTableAndColumnName()
                                         throws java.sql.SQLException
```
    Positive test - case sensitive table and column names
    
    Throws:
    
    java.sql.SQLException
  - testTableAndColumnNameWithSpaces
```
public void testTableAndColumnNameWithSpaces()
                                      throws java.sql.SQLException
```
    Positive test - table and column names with spaces in middle and end
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXNotForUpdateColumns
```
public void testUpdateXXXNotForUpdateColumns()
                                      throws java.sql.SQLException
```
    Positive test - call updateXXX methods on column that is not in for update columns list
    
    Throws:
    
    java.sql.SQLException
  - testUpdateTableDifferentSchema
```
public void testUpdateTableDifferentSchema()
                                    throws java.sql.SQLException
```
    Positive test - try to update a table from another schema
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowDeleteRowDoNotCommit
```
public void testUpdateRowDeleteRowDoNotCommit()
                                       throws java.sql.SQLException
```
    Positive test - in autocommit mode, check that updateRow and deleteRow does not commit
    
    Throws:
    
    java.sql.SQLException
  - testInsertRow
```
public void testInsertRow()
                   throws java.sql.SQLException
```
    Positive test - moveToInsertRow, insertRow, getXXX and moveToCurrentRow
    
    Throws:
    
    java.sql.SQLException
  - testUpdateRowDeleteRowFromInsertRow
```
public void testUpdateRowDeleteRowFromInsertRow()
                                         throws java.sql.SQLException
```
    Negative test - run updateRow and deleterow when positioned at insertRow
    
    Throws:
    
    java.sql.SQLException
  - testInsertRowFromCurrentRow
```
public void testInsertRowFromCurrentRow()
                                 throws java.sql.SQLException
```
    Negative test - Try to insertRow from current row
    
    Throws:
    
    java.sql.SQLException
  - testInsertRowFromDifferentPositions
```
public void testInsertRowFromDifferentPositions()
                                         throws java.sql.SQLException
```
    Positive test - try insertRow from different positions
    
    Throws:
    
    java.sql.SQLException
  - testInsertRowWithNullColumn
```
public void testInsertRowWithNullColumn()
                                 throws java.sql.SQLException
```
    Positive test - InsertRow leaving a nullable columns = NULL
    
    Throws:
    
    java.sql.SQLException
  - xTestInsertRowAfterCommit
```
public void xTestInsertRowAfterCommit()
                               throws java.sql.SQLException
```
    Positive and negative tests - Commit while on insertRow
    
    Throws:
    
    java.sql.SQLException
  - testInsertRowAfterClose
```
public void testInsertRowAfterClose()
                             throws java.sql.SQLException
```
    Negative test - test insertRow on closed resultset
    
    Throws:
    
    java.sql.SQLException
  - testInsertRowWithDefaultValue
```
public void testInsertRowWithDefaultValue()
                                   throws java.sql.SQLException
```
    Positive test - try to insert without updating all columns. All columns allow nulls or have a default value
    
    Throws:
    
    java.sql.SQLException
  - testRollbackWithAutoCommit
```
public void testRollbackWithAutoCommit()
                                throws java.sql.SQLException
```
    Positive test - Rollback with AutoCommit on
    
    Throws:
    
    java.sql.SQLException
  - testInsertRowReadOnlyRS
```
public void testInsertRowReadOnlyRS()
                             throws java.sql.SQLException
```
    Negative test - insertRow and read-only RS
    
    Throws:
    
    java.sql.SQLException
  - testUpdateXXXAllDataTypesInsertRow
```
public void testUpdateXXXAllDataTypesInsertRow()
                                        throws java.sql.SQLException,
                                               java.io.UnsupportedEncodingException
```
    Positive test - Test all updateXXX methods on all the supported sql datatypes
    
    Throws:
    
    java.sql.SQLException
    
    java.io.UnsupportedEncodingException
  - runTestUpdateXXXAllDataTypesInsertRow
```
private void runTestUpdateXXXAllDataTypesInsertRow(java.sql.PreparedStatement pstmt,
                                                   java.sql.PreparedStatement pstmt1,
                                                   int sqlType,
                                                   int updateXXXName)
                                            throws java.sql.SQLException,
                                                   java.io.UnsupportedEncodingException
```
    Throws:
    
    java.sql.SQLException
    
    java.io.UnsupportedEncodingException
  - createTableT1
```
private void createTableT1()
                    throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - createTableT2
```
private void createTableT2()
                    throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - createTableT3
```
private void createTableT3()
                    throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - createTableT4
```
private void createTableT4()
                    throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - createTableT5
```
private void createTableT5()
                    throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - createTableWithPrimaryKey
```
private void createTableWithPrimaryKey()
                                throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - createTable0WithTrigger
```
private void createTable0WithTrigger()
                              throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - createTable1WithTrigger
```
private void createTable1WithTrigger()
                              throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - createSelfReferencingTable
```
private void createSelfReferencingTable()
                                 throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - createAllDatatypesTable
```
private void createAllDatatypesTable()
                              throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - verifyData
```
private void verifyData(int sqlType,
                        int updateXXXName)
                 throws java.sql.SQLException,
                        java.io.UnsupportedEncodingException
```
    Throws:
    
    java.sql.SQLException
    
    java.io.UnsupportedEncodingException
  - resetData
```
private void resetData()
                throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException

Class UpdatableResultSetTest

Field Summary

Fields inherited from class org.apache.derbyTesting.junit.BaseTestCase

Constructor Summary

Method Summary

Methods inherited from class org.apache.derbyTesting.junit.BaseJDBCTestCase

Methods inherited from class org.apache.derbyTesting.junit.BaseTestCase

Methods inherited from class junit.framework.TestCase

Methods inherited from class java.lang.Object

Field Detail

allUpdateXXXNames

allSQLTypes

ColumnNames

SQLData

updateXXXRulesTableForEmbedded

updateXXXRulesTableForNetworkClient

updateObjectRulesTableForNetworkClient

Constructor Detail

UpdatableResultSetTest

Method Detail

suite

baseSuite

setUp

testScrollSensitiveResultSet

testUpdateDeleteRowOnReadOnlyResultSet

testUpdateDeleteRowOnReadOnlyResultSetWithForUpdate

testUpdateDeleteRowOnReadOnlyResultSetWithoutForUpdate

testUpdateDeleteRowOnUpdatableResultSetWithForReadOnly

testUpdateDeleteRowNotOnRow

testUpdateDeleteRowOnClosedResultSet

testUpdatableResultSetOnSysTable

testUpdatableResultSetOnView

testUpdatableResultSetOnJoin

testDropTableWithUpatableResultSet

testForeignKeyConstraintFailureOnDeleteRow

testForeignKeyConstraintFailureOnUpdateRow

testUpdateXXXOnColumnNotFromTable

testUpdateXXXOnOutOfRangeColumn

testResultSetNotPositionedAfterDeleteRow

testResultSetNotPositionedAfterUpdateRow

testPositionedDeleteOnUpdatableResultSet

testPositionedUpdateOnUpdatableResultSet

testUpdatableResultsetNoColumnInColumnList

testDeleteRowWithPreparedStatement

testUpdateXXXWithPreparedStatement

testCallableStatementWithUpdatableResultSet

testUpdatableResultSetWithoutSelectingPrimaryKey

testRowDeleted

testRowUpdated

testDeleteRowOnTempTable

testUpdateRowOnTempTable

testDeleteRowWithSetCursorName

testUpdateRowWithSetCursorName

testDeleteRowWithCorrelationForTableName

testDeleteRowWithCorrelationForColumnName

testUpdateXXXOnReadOnlyColumn

testUpdateRowWithCorrelationOnTableAndColumn

testUpdateXXXOnReadOnlyColumnWithCorrelationName

testTwoResultSetsDeletingSameRow

testSetFetchSizeOnUpdatableResultSet

testDeleteRowWithDeleteTrigger

testUpdateRowWithUpdateTrigger

testDeleteRowWithTriggerChangingRS

testUpdateRowWithTriggerChangingRS

testDeleteRowSelfReferential

testUpdateRowSelfReferential

testDropTableWithUpdatableCursorOnIt

testDeleteRowAndRollbackWithTriggers

testUpdateRowAndRollbackWithTriggers

testResultSetPositionedBeforeNextAfterDeleteRow

testCancelRowUpdatesOnReadOnlyRS

testUpdateRowOnReadOnlyRS

testUpdateXXXOnReadOnlyRS

testUpdateXXXWithAllDatatypes

runTestUpdateXXXWithAllDatatypes

testUpdateObjectWithAllDatatypes

runTestUpdateObjectWithAllDatatypes

testUpdateXXXWithCancelRowUpdates

testCancelRowUpdatesAndDeleteRow

testCancelRowUpdatesWithoutUpdateXXX