Java Code Examples for javax.sql.rowset.CachedRowSet#close()

@Test(dataProvider = "rowsetUsingCoffees", enabled = true)
public void commonCachedRowSetTest0059(CachedRowSet rs) throws Exception {
    int rowToDelete = 2;
    try (CachedRowSet crs1 = rsf.createCachedRowSet()) {
        rs.beforeFirst();
        crs1.populate(rs);
        TestRowSetListener rsl = new TestRowSetListener();
        crs1.addRowSetListener(rsl);
        // Delete a row, the PK is also the absolute position as a List
        // backs the RowSet
        crs1.absolute(rowToDelete);
        crs1.deleteRow();
        assertTrue(crs1.rowDeleted());
        assertFalse(findRowByPrimaryKey(crs1, rowToDelete, 1));
        // Restore back to our original state and the
        // previously deleted row should be there
        rsl.resetFlag();
        crs1.restoreOriginal();
        assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
        assertTrue(crs1.isBeforeFirst());
        crs1.absolute(rowToDelete);
        assertFalse(crs1.rowDeleted());
        assertTrue(findRowByPrimaryKey(crs1, rowToDelete, 1));
    }
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffees", enabled = true)
public void commonCachedRowSetTest0059(CachedRowSet rs) throws Exception {
    int rowToDelete = 2;
    try (CachedRowSet crs1 = rsf.createCachedRowSet()) {
        rs.beforeFirst();
        crs1.populate(rs);
        TestRowSetListener rsl = new TestRowSetListener();
        crs1.addRowSetListener(rsl);
        // Delete a row, the PK is also the absolute position as a List
        // backs the RowSet
        crs1.absolute(rowToDelete);
        crs1.deleteRow();
        assertTrue(crs1.rowDeleted());
        assertFalse(findRowByPrimaryKey(crs1, rowToDelete, 1));
        // Restore back to our original state and the
        // previously deleted row should be there
        rsl.resetFlag();
        crs1.restoreOriginal();
        assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
        assertTrue(crs1.isBeforeFirst());
        crs1.absolute(rowToDelete);
        assertFalse(crs1.rowDeleted());
        assertTrue(findRowByPrimaryKey(crs1, rowToDelete, 1));
    }
    rs.close();
}
 

@Test(dataProvider = "rowSetType")
public void commonCachedRowSetTest0011(CachedRowSet rs) throws Exception {
    int[] pkeys = {1, 3};
    assertNull(rs.getKeyColumns());
    rs.setKeyColumns(pkeys);
    assertEquals(rs.getKeyColumns(), pkeys);
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffeeHouses", enabled = false)
public void commonCachedRowSetTest0017(CachedRowSet rs) throws Exception {
    int[] expectedCols = {1};
    String[] expectedColNames = {"ID"};
    rs.setMatchColumn(expectedColNames[0]);
    int[] actualCols = rs.getMatchColumnIndexes();
    String[] actualColNames = rs.getMatchColumnNames();
    assertEquals(actualCols, expectedCols);
    assertEquals(actualColNames, expectedColNames);
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffees")
public void commonCachedRowSetTest0056(CachedRowSet rs) throws Exception {
    String coffee = "Hazelnut";
    int sales = 100;
    int id = 200;
    Object[] updatedPkeys = {1, id, 3, 4, 5};
    // Change the coffee name and sales total for row 2 and save the
    // previous values
    rs.absolute(2);
    int origId = rs.getInt(1);
    String origCoffee = rs.getString(2);
    int origSales = rs.getInt(5);
    rs.updateInt(1, id);
    rs.updateString(2, coffee);
    rs.updateInt(5, sales);
    // MetaData should match
    try ( // Get the original original RowSet and validate that the changes
            // are only made to the current, not the original
            ResultSet rs1 = rs.getOriginal()) {
        // MetaData should match
        compareMetaData(rs.getMetaData(), rs1.getMetaData());
        assertTrue(rs1.isBeforeFirst());
        assertTrue(rs1.getConcurrency() == ResultSet.CONCUR_UPDATABLE);
        assertTrue(rs1.getType() == ResultSet.TYPE_SCROLL_INSENSITIVE);
        rs1.absolute(2);
        // Check original rowset is not changed
        assertTrue(rs1.getInt(1) == origId);
        assertTrue(rs1.getString(2).equals(origCoffee));
        assertTrue(rs1.getInt(5) == origSales);
        assertEquals(getPrimaryKeys(rs1), COFFEES_PRIMARY_KEYS);
        // Check current rowset
        assertTrue(rs.getInt(1) == id);
        assertTrue(rs.getString(2).equals(coffee));
        assertTrue(rs.getInt(5) == sales);
        assertEquals(getPrimaryKeys(rs), updatedPkeys);
    }
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffeeHouses")
public void commonCachedRowSetTest0054(CachedRowSet rs) throws Exception {
    int rowToDelete = 1961;
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS);
    // Add new row
    rs.moveToInsertRow();
    rs.updateInt(1, rowToDelete);
    rs.updateString(2, "GOTHAM");
    rs.updateInt(3, 3450);
    rs.updateInt(4, 2005);
    rs.updateInt(5, 5455);
    rs.insertRow();
    rs.moveToCurrentRow();
    // check that the number of rows has increased
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1);
    assertTrue(findRowByPrimaryKey(rs, rowToDelete, 1));
    rs.absolute(COFFEE_HOUSES_ROWS + 1);
    rs.deleteRow();
    // Check to make sure the row is no longer there
    //assertTrue(rs.size() ==  COFFEE_HOUSES_ROWS);
    assertFalse(findRowByPrimaryKey(rs, rowToDelete, 1));
    rs.setShowDeleted(true);
    rs.absolute(COFFEE_HOUSES_ROWS + 1);
    rs.undoDelete();
    // check that the row is back
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1);
    assertTrue(findRowByPrimaryKey(rs, rowToDelete, 1));
    rs.close();
}
 

@Test(dataProvider = "rowSetType")
public void commonCachedRowSetTest0003(CachedRowSet rs) throws SQLException {

    // Register a provider and make sure it is avaiable
    SyncFactory.registerProvider(stubProvider);
    rs.setSyncProvider(stubProvider);
    SyncProvider sp = rs.getSyncProvider();
    assertTrue(sp instanceof StubSyncProvider);
    SyncFactory.unregisterProvider(stubProvider);
    rs.close();
}
 

@Test(dataProvider = "rowSetType")
public void commonCachedRowSetTest0010(CachedRowSet rs) throws Exception {
    assertNull(rs.getTableName());
    rs.setTableName(COFFEE_HOUSES_TABLE);
    assertTrue(rs.getTableName().equals(COFFEE_HOUSES_TABLE));
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffeeHouses")
public void commonCachedRowSetTest0037(CachedRowSet rs) throws Exception {
    try (CachedRowSet crs1 = rs.createCopySchema()) {
        assertTrue(crs1.size() == 0);
        compareMetaData(crs1.getMetaData(), rs.getMetaData());
    }
    rs.close();
}
 

@Test(dataProvider = "createCachedRowSetsToUse")
public void joinRowSetTests0001(CachedRowSet crs, CachedRowSet crs1)
        throws Exception {

    try (JoinRowSet jrs = newInstance()) {
        jrs.addRowSet(crs, COFFEES_JOIN_COLUMN_INDEX);
        jrs.addRowSet(crs1, SUPPLIERS_JOIN_COLUMN_INDEX);
        validateResults(jrs);
        crs.close();
        crs1.close();
    }
}
 

@Test(dataProvider = "rowsetUsingCoffeeHouses")
public void commonCachedRowSetTest0054(CachedRowSet rs) throws Exception {
    int rowToDelete = 1961;
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS);
    // Add new row
    rs.moveToInsertRow();
    rs.updateInt(1, rowToDelete);
    rs.updateString(2, "GOTHAM");
    rs.updateInt(3, 3450);
    rs.updateInt(4, 2005);
    rs.updateInt(5, 5455);
    rs.insertRow();
    rs.moveToCurrentRow();
    // check that the number of rows has increased
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1);
    assertTrue(findRowByPrimaryKey(rs, rowToDelete, 1));
    rs.absolute(COFFEE_HOUSES_ROWS + 1);
    rs.deleteRow();
    // Check to make sure the row is no longer there
    //assertTrue(rs.size() ==  COFFEE_HOUSES_ROWS);
    assertFalse(findRowByPrimaryKey(rs, rowToDelete, 1));
    rs.setShowDeleted(true);
    rs.absolute(COFFEE_HOUSES_ROWS + 1);
    rs.undoDelete();
    // check that the row is back
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1);
    assertTrue(findRowByPrimaryKey(rs, rowToDelete, 1));
    rs.close();
}
 

@Test(dataProvider = "rowSetType")
public void commonCachedRowSetTest0005(CachedRowSet rs) throws Exception {
    TestRowSetListener rsl = new TestRowSetListener();
    rs.addRowSetListener(rsl);
    rs.restoreOriginal();
    assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffeeHouses")
public void commonCachedRowSetTest0055(CachedRowSet rs) throws Exception {
    int rowToInsert = 1961;
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS);
    // Add new row
    rs.moveToInsertRow();
    rs.updateInt(1, rowToInsert);
    rs.updateString(2, "GOTHAM");
    rs.updateInt(3, 3450);
    rs.updateInt(4, 2005);
    rs.updateInt(5, 5455);
    rs.insertRow();
    rs.moveToCurrentRow();
    // check that the number of rows has increased
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1);
    assertTrue(findRowByPrimaryKey(rs, rowToInsert, 1));
    rs.absolute(COFFEE_HOUSES_ROWS + 1);
    // Save off the original column values
    String f2 = rs.getString(2);
    int f3 = rs.getInt(3);
    rs.updateString(2, "SMALLVILLE");
    rs.updateInt(3, 500);
    // Validate the columns have been updated
    assertTrue(rs.columnUpdated(2));
    assertTrue(rs.columnUpdated(3));
    // Undo the update and validate it has taken place
    rs.absolute(COFFEE_HOUSES_ROWS + 1);
    rs.undoUpdate();
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS);
    assertFalse(findRowByPrimaryKey(rs, rowToInsert, 1));
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffees", enabled = true)
public void commonCachedRowSetTest0060(CachedRowSet rs) throws Exception {
    int rowToUpdate = 2;
    String coffee = "Hazelnut";
    try (CachedRowSet crs1 = rsf.createCachedRowSet()) {
        rs.beforeFirst();
        crs1.populate(rs);
        TestRowSetListener rsl = new TestRowSetListener();
        crs1.addRowSetListener(rsl);
        // Delete a row, the PK is also the absolute position as a List
        // backs the RowSet
        crs1.absolute(rowToUpdate);
        String origCoffee = crs1.getString(2);
        crs1.updateString(2, coffee);
        assertTrue(crs1.columnUpdated(2));
        crs1.updateRow();
        assertTrue(crs1.rowUpdated());
        assertFalse(origCoffee.equals(crs1.getString(2)));
        // Restore back to our original state and the
        // previous value for the column within the row should be there
        rsl.resetFlag();
        crs1.restoreOriginal();
        assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED));
        assertTrue(crs1.isBeforeFirst());
        // absolute() is failing for some reason so need to look at this later
        crs1.next();
        crs1.next();
        assertFalse(crs1.columnUpdated(2));
        assertFalse(crs1.rowUpdated());
        assertTrue(origCoffee.equals(crs1.getString(2)));
    }
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffeeHouses")
public void commonCachedRowSetTest0055(CachedRowSet rs) throws Exception {
    int rowToInsert = 1961;
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS);
    // Add new row
    rs.moveToInsertRow();
    rs.updateInt(1, rowToInsert);
    rs.updateString(2, "GOTHAM");
    rs.updateInt(3, 3450);
    rs.updateInt(4, 2005);
    rs.updateInt(5, 5455);
    rs.insertRow();
    rs.moveToCurrentRow();
    // check that the number of rows has increased
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1);
    assertTrue(findRowByPrimaryKey(rs, rowToInsert, 1));
    rs.absolute(COFFEE_HOUSES_ROWS + 1);
    // Save off the original column values
    String f2 = rs.getString(2);
    int f3 = rs.getInt(3);
    rs.updateString(2, "SMALLVILLE");
    rs.updateInt(3, 500);
    // Validate the columns have been updated
    assertTrue(rs.columnUpdated(2));
    assertTrue(rs.columnUpdated(3));
    // Undo the update and validate it has taken place
    rs.absolute(COFFEE_HOUSES_ROWS + 1);
    rs.undoUpdate();
    assertTrue(rs.size() == COFFEE_HOUSES_ROWS);
    assertFalse(findRowByPrimaryKey(rs, rowToInsert, 1));
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffeeHouses")
public void commonCachedRowSetTest0036(CachedRowSet rs) throws Exception {
    try (CachedRowSet crs1 = rs.createCopy()) {
        compareRowSets(rs, crs1);
    }
    rs.close();
}
 

@Test(dataProvider = "rowsetUsingCoffeeHouses",
        expectedExceptions = SQLException.class)
public void commonCachedRowSetTest0021(CachedRowSet rs) throws Exception {
    String matchColumn = "ID";
    rs.setMatchColumn(matchColumn);
    String[] actualColNames = rs.getMatchColumnNames();
    assertTrue(actualColNames != null);
    rs.unsetMatchColumn(matchColumn);
    actualColNames = rs.getMatchColumnNames();
    rs.close();
}
 

@Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class)
public void commonCachedRowSetTest0031(CachedRowSet rs) throws Exception {
    rs.previousPage();
    rs.close();
}
 

@Test(dataProvider = "rowSetType", expectedExceptions = SyncProviderException.class)
public void commonCachedRowSetTest0000(CachedRowSet rs) throws Exception {
    rs.acceptChanges();
    rs.close();
}
 

@Test(dataProvider = "rowSetType", expectedExceptions = SyncProviderException.class)
public void commonCachedRowSetTest0000(CachedRowSet rs) throws Exception {
    rs.acceptChanges();
    rs.close();
}