Examples of javax.sql.rowset.FilteredRowSet

javax.sql.rowset.FilteredRowSet
names from "Alpha" to "Bravo" will be returned} In the example above, we initialize a Range object which implements the Predicate interface. This object expresses the following constraints: All rows outputted or modified from this FilteredRowSet object must fall between the values 'Alpha' and 'Bravo' both values inclusive, in the column 'columnName'. If a filter is applied to a FilteredRowSet object that contains no data that falls within the range of the filter, no rows are returned.
This framework allows multiple classes implementing predicates to be used in combination to achieved the required filtering result with out the need for query language processing.
4.0 Updating a FilteredRowSet Object
The predicate set on a FilteredRowSet object applies a criterion on all rows in a RowSet object to manage a subset of rows in a RowSet object. This criterion governs the subset of rows that are visible and also defines which rows can be modified, deleted or inserted.
Therefore, the predicate set on a FilteredRowSet object must be considered as bi-directional and the set criterion as the gating mechanism for all views and updates to the FilteredRowSet object. Any attempt to update the FilteredRowSet that violates the criterion will result in a SQLException object being thrown.
The FilteredRowSet range criterion can be modified by applying a new Predicate object to the FilteredRowSet instance at any time. This is possible if no additional references to the FilteredRowSet object are detected. A new filter has has an immediate effect on criterion enforcement within the FilteredRowSet object, and all subsequent views and updates will be subject to similar enforcement.
5.0 Behavior of Rows Outside the Filter
Rows that fall outside of the filter set on a FilteredRowSet object cannot be modified until the filter is removed or a new filter is applied.
Furthermore, only rows that fall within the bounds of a filter will be synchronized with the data source. @author Jonathan Bruce

        assertTrue(filteredRowSet.first());
        assertEquals(1, filteredRowSet.getInt(1));
    }


    public void testAbsolute() throws Exception {
        FilteredRowSet filteredRowSet = newFilterRowSet();
        rs = st.executeQuery("SELECT * FROM USER_INFO");
        filteredRowSet.populate(rs);
        /*
         * When running on RI, filteredRowSet.absolute(1) is false here.
         * However, the cursor moves to the first row already.
         */
        if ("true".equals(System.getProperty("Testing Harmony"))) {
            assertTrue(filteredRowSet.absolute(1));
        } else {
            assertFalse(filteredRowSet.absolute(1));
        }
        assertEquals("hermit", filteredRowSet.getString(2));


        RangeOne range = new RangeOne();
        filteredRowSet.setFilter(range);


        /*
         * When running on RI, filteredRowSet.absolute(1) is false.
         */
        if ("true".equals(System.getProperty("Testing Harmony"))) {
            assertTrue(filteredRowSet.absolute(1));
        } else {
            assertFalse(filteredRowSet.absolute(1));
        }
        assertEquals("test", filteredRowSet.getString(2));
        range.clear();
        assertTrue(filteredRowSet.absolute(2));
        assertEquals(3, filteredRowSet.getRow());
        assertEquals(3, filteredRowSet.getInt(1));
        assertEquals(EVALUATE_ROWSET, range.getTag());
        assertEquals(3, range.getCount());


        range.clear();
        assertTrue(filteredRowSet.absolute(2));
        assertEquals(3, filteredRowSet.getInt(1));
        assertEquals(EVALUATE_ROWSET, range.getTag());
        assertEquals(3, range.getCount());


        range.clear();
        assertTrue(filteredRowSet.absolute(3));
        assertEquals(4, filteredRowSet.getInt(1));
        assertEquals(EVALUATE_ROWSET, range.getTag());
        assertEquals(4, range.getCount());


        assertFalse(filteredRowSet.absolute(4));


        assertTrue(filteredRowSet.absolute(-2));
        assertEquals(3, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.absolute(-3));
        assertEquals(2, filteredRowSet.getInt(1));


        assertFalse(filteredRowSet.absolute(-4));
        assertTrue(filteredRowSet.isBeforeFirst());
    }

View Full Code Here

        assertFalse(filteredRowSet.absolute(-4));
        assertTrue(filteredRowSet.isBeforeFirst());
    }


    public void testRelative() throws Exception {
        FilteredRowSet filteredRowSet = newFilterRowSet();
        rs = st.executeQuery("SELECT * FROM USER_INFO");
        filteredRowSet.populate(rs);


        assertTrue(filteredRowSet.absolute(3));
        assertEquals(3, filteredRowSet.getInt(1));
        assertFalse(filteredRowSet.relative(2));


        assertTrue(filteredRowSet.absolute(3));
        assertEquals(3, filteredRowSet.getInt(1));
        assertTrue(filteredRowSet.relative(1));
        assertEquals(4, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.absolute(3));
        assertEquals(3, filteredRowSet.getInt(1));
        assertTrue(filteredRowSet.relative(-1));
        assertEquals(2, filteredRowSet.getInt(1));
        assertFalse(filteredRowSet.relative(-2));


        RangeOne range = new RangeOne();
        filteredRowSet.setFilter(range);


        filteredRowSet.beforeFirst();
        assertTrue(filteredRowSet.relative(2));
        assertEquals(3, filteredRowSet.getInt(1));
        assertEquals(3, filteredRowSet.getRow());
        assertFalse(filteredRowSet.relative(-2));
        assertTrue(filteredRowSet.isBeforeFirst());
    }

View Full Code Here

        assertTrue(filteredRowSet.isBeforeFirst());
    }


    public void testCursorMove() throws Exception {
        insertMoreData(30);
        FilteredRowSet filteredRowSet = newFilterRowSet();
        rs = st.executeQuery("SELECT * FROM USER_INFO");
        filteredRowSet.populate(rs);
        RangeThree range = new RangeThree();
        filteredRowSet.setFilter(range);


        assertTrue(filteredRowSet.first());
        assertEquals("hermit", filteredRowSet.getString(2));
        /*
         * TODO It's really strange. When running on RI, filteredRowSet.first()
         * is true. The cursor stays on the first row. However,
         * filteredRowSet.absolute(1) is false. But the cursor still stays on
         * the first row.
         */
        if ("true".equals(System.getProperty("Testing Harmony"))) {
            assertTrue(filteredRowSet.absolute(1));
        } else {
            assertFalse(filteredRowSet.absolute(1));
        }
        assertEquals("hermit", filteredRowSet.getString(2));
        assertTrue(filteredRowSet.relative(1));
        assertEquals("test4", filteredRowSet.getString(2));
        /*
         * First call absolute(2), then call relative(-1), the cursor returns
         * the first row.
         */
        assertTrue(filteredRowSet.absolute(2));
        assertEquals("test4", filteredRowSet.getString(2));
        assertTrue(filteredRowSet.relative(-1));
        assertEquals("hermit", filteredRowSet.getString(2));


        assertTrue(filteredRowSet.last());
        assertEquals("test34", filteredRowSet.getString(2));


        assertTrue(filteredRowSet.previous());
        assertEquals("test32", filteredRowSet.getString(2));


        assertTrue(filteredRowSet.relative(-1));
        assertEquals("test30", filteredRowSet.getString(2));


        assertTrue(filteredRowSet.absolute(5));
        assertEquals("test10", filteredRowSet.getString(2));


        assertTrue(filteredRowSet.relative(3));
        assertEquals("test16", filteredRowSet.getString(2));


        assertTrue(filteredRowSet.relative(-3));
        assertEquals("test10", filteredRowSet.getString(2));


        assertTrue(filteredRowSet.relative(4));
        assertEquals("test18", filteredRowSet.getString(2));


        assertTrue(filteredRowSet.relative(13));
        assertEquals("test34", filteredRowSet.getString(2));


        assertFalse(filteredRowSet.next());
        assertTrue(filteredRowSet.isAfterLast());


        assertTrue(filteredRowSet.absolute(22));
        assertEquals("test34", filteredRowSet.getString(2));


        assertTrue(filteredRowSet.relative(-21));
        assertEquals("hermit", filteredRowSet.getString(2));


        assertFalse(filteredRowSet.relative(-1));
        assertTrue(filteredRowSet.isBeforeFirst());
    }

View Full Code Here

        assertFalse(filteredRowSet.relative(-1));
        assertTrue(filteredRowSet.isBeforeFirst());
    }


    public void testNextAndPrevious() throws Exception {
        FilteredRowSet filteredRowSet = newFilterRowSet();
        rs = st.executeQuery("SELECT * FROM USER_INFO");
        filteredRowSet.populate(rs);


        RangeOne range = new RangeOne();
        filteredRowSet.setFilter(range);


        assertTrue(filteredRowSet.next());
        assertEquals(2, filteredRowSet.getInt(1));
        assertEquals(EVALUATE_ROWSET, range.getTag());
        assertEquals(2, range.getCount());
        range.clear();
        assertTrue(filteredRowSet.next());
        assertEquals(3, filteredRowSet.getInt(1));
        assertEquals(EVALUATE_ROWSET, range.getTag());
        assertEquals(1, range.getCount());


        range.clear();
        assertTrue(filteredRowSet.previous());
        assertEquals(2, filteredRowSet.getInt(1));
        assertEquals(1, range.getCount());
        range.clear();
        assertFalse(filteredRowSet.previous());
        assertEquals(EVALUATE_ROWSET, range.getTag());
    }

View Full Code Here

        assertFalse(filteredRowSet.previous());
        assertEquals(EVALUATE_ROWSET, range.getTag());
    }


    public void testNoFilter_Insert() throws Exception {
        FilteredRowSet filteredRowSet = newFilterRowSet();
        rs = st.executeQuery("SELECT * FROM USER_INFO");
        filteredRowSet.populate(rs);


        /*
         * TODO Call updateXXX() would throw NullPointerException on insert row
         * when running on RI.
         */
        filteredRowSet.moveToInsertRow();
        filteredRowSet.updateInt(1, 10);
        filteredRowSet.updateString(2, "insert10");
        filteredRowSet.insertRow();
        filteredRowSet.moveToCurrentRow();
    }

View Full Code Here

        filteredRowSet.insertRow();
        filteredRowSet.moveToCurrentRow();
    }


    public void testFilter_Insert() throws Exception {
        FilteredRowSet filteredRowSet = newFilterRowSet();
        rs = st.executeQuery("SELECT * FROM USER_INFO");
        filteredRowSet.populate(rs);


        Predicate range = new RangeOne();
        filteredRowSet.setFilter(range);


        /*
         * Insert a row. when call updateXXX(), evaluate(Object value, int
         * column) is called to check first.
         */
        filteredRowSet.afterLast();
        filteredRowSet.moveToInsertRow();
        filteredRowSet.updateInt(1, 200);
        try {
            filteredRowSet.updateString("NAME", "test200");
            fail("should throw SQLException");
        } catch (SQLException e) {
            filteredRowSet.updateString("NAME", "insert200");
        }
        filteredRowSet.insertRow();
        filteredRowSet.moveToCurrentRow();


        /*
         * Although the new row is inserted, it is invalid through
         * evaluate(RowSet rs). Therefore, the inserted row is not visible.
         */
        filteredRowSet.beforeFirst();
        int index = 0;
        while (filteredRowSet.next()) {
            index++;
            assertEquals(index + 1, filteredRowSet.getInt(1));
        }
        assertEquals(3, index);


        /*
         * Remove filter. See the inserted row. Then set again, and commit to
         * database.
         */
        filteredRowSet.setFilter(null);
        assertTrue(filteredRowSet.last());
        assertEquals(200, filteredRowSet.getInt(1));
        assertTrue(filteredRowSet.rowInserted());
        filteredRowSet.setFilter(range);
        filteredRowSet.acceptChanges(conn);
        // check database: the inserted row isn't commited to database
        rs = st.executeQuery("SELECT * FROM USER_INFO");
        index = 0;
        while (rs.next()) {
            index++;
            assertEquals(index, rs.getInt(1));
        }
        assertEquals(4, index);


        /*
         * Remove filter
         */
        filteredRowSet.setFilter(null);
        filteredRowSet.beforeFirst();
        index = 0;
        while (filteredRowSet.next()) {
            index++;
            if (index == 5) {
                /*
                 * Though the new row isn't inserted into database, the inserted
                 * row lost it's status after acceptChanges().
                 */
                assertEquals(200, filteredRowSet.getInt(1));
                assertFalse(filteredRowSet.rowInserted());
            } else {
                assertEquals(index, filteredRowSet.getInt(1));
            }
        }
        assertEquals(5, index);
    }

View Full Code Here

        }
        assertEquals(5, index);
    }


    public void testFilter_Update() throws Exception {
        FilteredRowSet filteredRowSet = newFilterRowSet();
        rs = st.executeQuery("SELECT * FROM USER_INFO");
        filteredRowSet.populate(rs);


        Predicate range = new RangeOne();
        filteredRowSet.setFilter(range);


        /*
         * Update the third row. Filter has no effect here.
         */
        assertTrue(filteredRowSet.last());
        assertEquals("test4", filteredRowSet.getString(2));
        filteredRowSet.updateString(2, "update4");
        filteredRowSet.updateRow();
        assertEquals("update4", filteredRowSet.getString(2));
        // the updated row becomes not visible through filter
        assertTrue(filteredRowSet.last());
        assertEquals("test3", filteredRowSet.getString(2));


        // commit to database
        filteredRowSet.acceptChanges(conn);
        rs = st
                .executeQuery("SELECT COUNT(*) FROM USER_INFO WHERE NAME = 'update4'");
        assertTrue(rs.next());
        assertEquals(0, rs.getInt(1));


        /*
         * Remove filter
         */
        filteredRowSet.setFilter(null);
        assertTrue(filteredRowSet.last());
        assertEquals("update4", filteredRowSet.getString(2));
        /*
         * The forth row isn't updated to database, and it lost it's status
         * after acceptChanges().
         */
        assertFalse(filteredRowSet.rowUpdated());
    }

View Full Code Here

         */
        assertFalse(filteredRowSet.rowUpdated());
    }


    public void testFilter_Delete() throws Exception {
        FilteredRowSet filteredRowSet = newFilterRowSet();
        rs = st.executeQuery("SELECT * FROM USER_INFO");
        filteredRowSet.populate(rs);


        /*
         * Mark the first row as delete.
         */
        assertTrue(filteredRowSet.first());
        assertEquals(1, filteredRowSet.getInt(1));
        filteredRowSet.deleteRow();


        Predicate range = new RangeOne();
        filteredRowSet.setFilter(range);


        assertTrue(filteredRowSet.first());
        assertEquals(2, filteredRowSet.getInt(1));


        filteredRowSet.acceptChanges(conn);
        rs = st.executeQuery("SELECT COUNT(*) FROM USER_INFO WHERE ID = 1");
        assertTrue(rs.next());
        assertEquals(1, rs.getInt(1));


        /*
         * Remove filter
         */
        filteredRowSet.setFilter(null);
        filteredRowSet.acceptChanges(conn);
        rs = st.executeQuery("SELECT COUNT(*) FROM USER_INFO WHERE ID = 1");
        assertTrue(rs.next());
        assertEquals(1, rs.getInt(1));
        /*
         * The first row has been deleted from FilteredRowSet. However, it isn't
         * deleted from database.
         */
        filteredRowSet.setShowDeleted(true);
        assertTrue(filteredRowSet.first());
        assertEquals(2, filteredRowSet.getInt(1));
    }

View Full Code Here

    }


    public void testPaging() throws Exception {
        insertMoreData(4);


        FilteredRowSet filteredRowSet = newFilterRowSet();


        filteredRowSet.setCommand("select * from USER_INFO");
        filteredRowSet.setUrl(DERBY_URL);


        filteredRowSet.setPageSize(3);
        filteredRowSet.execute();


        Predicate filter = new OddRowFilter();


        filteredRowSet.setFilter(filter);


        assertEquals("select * from USER_INFO", filteredRowSet.getCommand());


        assertFalse(filteredRowSet.previousPage());


        assertTrue(filteredRowSet.next());
        assertEquals(1, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.next());
        assertEquals(3, filteredRowSet.getInt(1));


        assertFalse(filteredRowSet.next());
        assertTrue(filteredRowSet.isAfterLast());


        if (!"true".equals(System.getProperty("Testing Harmony"))) {
            // RI need nextPage one more time
            assertTrue(filteredRowSet.nextPage());
        }


        int index = 5;
        while (filteredRowSet.nextPage()) {
            while (filteredRowSet.next()) {
                assertEquals(index, filteredRowSet.getInt(1));
                index += 2;
            }
        }


        assertEquals(9, index);


        filteredRowSet = newFilterRowSet();
        filteredRowSet.setCommand("select * from USER_INFO");
        filteredRowSet.setUrl(DERBY_URL);


        filteredRowSet.setPageSize(3);
        filteredRowSet.execute();


        filteredRowSet.setFilter(filter);


        assertTrue(filteredRowSet.next());
        assertEquals(1, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.nextPage());
        if (!"true".equals(System.getProperty("Testing Harmony"))) {
            // RI need nextPage one more time
            assertTrue(filteredRowSet.nextPage());
        }


        assertTrue(filteredRowSet.next());


        assertEquals(5, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.nextPage());


        assertTrue(filteredRowSet.next());
        assertEquals(7, filteredRowSet.getInt(1));


        assertFalse(filteredRowSet.nextPage());


    }

View Full Code Here


    }


    public void testPagingInMemory() throws Exception {
        insertMoreData(10);
        FilteredRowSet filteredRowSet = newFilterRowSet();


        st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                ResultSet.CONCUR_UPDATABLE);
        rs = st.executeQuery("SELECT * FROM USER_INFO");


        // the max rows load into memory
        filteredRowSet.setMaxRows(5);
        filteredRowSet.setPageSize(3);


        filteredRowSet.populate(rs, 1);


        OddRowFilter filter = new OddRowFilter();
        filteredRowSet.setFilter(filter);


        if (!"true".equals(System.getProperty("Testing Harmony"))) {
            // RI need nextPage one more time
            assertTrue(filteredRowSet.nextPage());
        }


        assertTrue(filteredRowSet.next());
        assertEquals(1, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.next());
        assertEquals(3, filteredRowSet.getInt(1));


        assertFalse(filteredRowSet.next());
        assertTrue(filteredRowSet.isAfterLast());


        assertTrue(filteredRowSet.nextPage());


        filteredRowSet.beforeFirst();


        assertTrue(filteredRowSet.next());
        assertEquals(5, filteredRowSet.getInt(1));


        assertFalse(filteredRowSet.next());
        assertTrue(filteredRowSet.isAfterLast());


        assertFalse(filteredRowSet.nextPage());


        st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                ResultSet.CONCUR_UPDATABLE);
        rs = st.executeQuery("SELECT * FROM USER_INFO");


        filteredRowSet = newFilterRowSet();
        filteredRowSet.setFilter(filter);
        filteredRowSet.setPageSize(3);


        filteredRowSet.populate(rs, 1);


        if (!"true".equals(System.getProperty("Testing Harmony"))) {
            // RI need nextPage one more time
            assertTrue(filteredRowSet.nextPage());
        }


        assertTrue(filteredRowSet.next());
        assertEquals(1, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.next());
        assertEquals(3, filteredRowSet.getInt(1));


        assertFalse(filteredRowSet.next());
        assertTrue(filteredRowSet.isAfterLast());


        filteredRowSet.setPageSize(2);
        assertTrue(filteredRowSet.nextPage());


        assertTrue(filteredRowSet.isBeforeFirst());


        assertTrue(filteredRowSet.next());
        assertEquals(5, filteredRowSet.getInt(1));


        assertFalse(filteredRowSet.next());
        assertTrue(filteredRowSet.isAfterLast());


        filteredRowSet.setPageSize(5);
        assertTrue(filteredRowSet.nextPage());


        assertTrue(filteredRowSet.isBeforeFirst());


        assertTrue(filteredRowSet.next());
        assertEquals(7, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.next());
        assertEquals(9, filteredRowSet.getInt(1));


        assertFalse(filteredRowSet.next());
        assertTrue(filteredRowSet.isAfterLast());


        assertTrue(filteredRowSet.previousPage());


        assertTrue(filteredRowSet.isBeforeFirst());


        assertTrue(filteredRowSet.next());
        assertEquals(1, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.next());
        assertEquals(3, filteredRowSet.getInt(1));


        assertTrue(filteredRowSet.next());
        assertEquals(5, filteredRowSet.getInt(1));


        assertFalse(filteredRowSet.next());
        assertTrue(filteredRowSet.isAfterLast());


        assertFalse(filteredRowSet.previousPage());
    }

View Full Code Here

0 1 2 3 4 5

TOP

Related Classes of javax.sql.rowset.FilteredRowSet

org.apache.harmony.sql.tests.internal.rowset.FilteredRowSetTest

org.apache.harmony.sql.tests.internal.rowset.JoinRowSetTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of javax.sql.rowset.FilteredRowSet

4.0 Updating a FilteredRowSet Object

5.0 Behavior of Rows Outside the Filter

Related Classes of javax.sql.rowset.FilteredRowSet

4.0 Updating a `FilteredRowSet` Object