Examples of org.hsqldb.navigator.RowIterator

org.hsqldb.navigator.RowIterator
@author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.7.2


                        table.insertIntoTable(session, result);
                    }


                    if (table.hasLobColumn) {
                        RowIterator it = table.rowIterator(session);


                        while (it.hasNext()) {
                            Row      row  = it.getNextRow();
                            Object[] data = row.getData();


                            session.sessionData.adjustLobUsageCount(table,
                                    data, 1);
                        }

View Full Code Here

                    if (script) {
                        schemaToLog = t.getName().schema;


                        writeTableInit(t);


                        RowIterator it = t.rowIterator(currentSession);


                        while (it.hasNext()) {
                            writeRow(currentSession, t,
                                     it.getNextRow().getData());
                        }


                        writeTableTerm(t);
                    }
                } catch (Exception e) {

View Full Code Here

        long count = 0;


        readLock.lock();


        try {
            RowIterator it = firstRow(session, store, 0);


            while (it.hasNext()) {
                it.getNextRow();


                count++;
            }


            return count;

View Full Code Here

        RowStoreAVLHybrid tempStore = new RowStoreAVLHybridExtended(session,
            manager, table, true);


        tempStore.changeToDiskTable(session);


        RowIterator iterator = table.rowIterator(this);


        while (iterator.hasNext()) {
            Row row = iterator.getNextRow();
            Row newRow = (Row) tempStore.getNewCachedObject(session,
                row.getData(), false);


            tempStore.indexRow(session, newRow);
        }

View Full Code Here


                if (nulls != 0
                        && (opType == OpTypes.MATCH_PARTIAL
                            || opType == OpTypes.MATCH_UNIQUE_PARTIAL)) {
                    boolean hasMatch = false;
                    RowIterator it =
                        nodes[RIGHT].getTable().rowIterator(session);


                    while (it.hasNext()) {
                        Object[] rowData = it.getNextRow().getData();
                        Boolean result = compareValues(session, data, rowData);


                        if (result == null) {
                            continue;
                        }


                        if (result.booleanValue()) {
                            if (opType == OpTypes.MATCH_PARTIAL) {
                                return Boolean.TRUE;
                            }


                            if (hasMatch) {
                                return Boolean.FALSE;
                            }


                            hasMatch = true;
                        }
                    }


                    return hasMatch ? Boolean.TRUE
                                    : Boolean.FALSE;
                }


                RowIterator it =
                    nodes[RIGHT].getTable().getPrimaryIndex().findFirstRow(
                        session, store, data);
                boolean result = it.hasNext();


                if (!result) {
                    return Boolean.FALSE;
                }


                switch (opType) {


                    case OpTypes.MATCH_SIMPLE :
                    case OpTypes.MATCH_PARTIAL :
                    case OpTypes.MATCH_FULL :
                        return Boolean.TRUE;
                }


                it.getNextRow();


                result = it.hasNext();


                if (!result) {
                    return Boolean.TRUE;
                }


                Object[] rowData = it.getNextRow().getData();
                Boolean returnValue =
                    Boolean.TRUE.equals(compareValues(session, data, rowData))
                    ? Boolean.FALSE
                    : Boolean.TRUE;

View Full Code Here

                                   TableDerived td) {


        Table           table = td;
        boolean         empty = table.isEmpty(session);
        Index           index = table.getFullIndex(session);
        RowIterator     it;
        PersistentStore store = table.getRowStore(session);
        Row             firstrow;
        Row             lastrow;
        Object[]        firstdata;
        Object[]        lastdata;
        boolean         hasNullValue = false;


        for (int i = 0; i < table.columnCount; i++) {
            hasNullValue |= store.hasNull(i);
        }


        switch (exprSubType) {


            case OpTypes.ANY_QUANTIFIED : {
                if (empty) {
                    return Boolean.FALSE;
                }


                if (countNulls(data) == data.length) {
                    return null;
                }


                convertToType(session, data, nodes[LEFT].nodeDataTypes,
                              nodes[RIGHT].nodeDataTypes);


                if (opType == OpTypes.EQUAL) {
                    it = index.findFirstRow(session, store, data);


                    if (it.hasNext()) {
                        return Boolean.TRUE;
                    } else {
                        if (hasNullValue) {
                            return null;
                        } else {
                            return Boolean.FALSE;
                        }
                    }
                }


                if (opType == OpTypes.NOT_EQUAL) {
                    it = index.firstRow(session, store, 0);
                } else {
                    it = index.findFirstRowNotNull(session, store);
                }


                firstrow = it.getNextRow();


                if (firstrow == null) {
                    return null;
                }


                firstdata = firstrow.getData();
                lastrow   = index.lastRow(session, store, 0).getNextRow();
                lastdata  = lastrow.getData();


                Boolean comparefirst = compareValues(session, data, firstdata);
                Boolean comparelast  = compareValues(session, data, lastdata);


                switch (opType) {


                    case OpTypes.NOT_EQUAL :
                        if (Boolean.TRUE.equals(comparefirst)
                                || Boolean.TRUE.equals(comparelast)) {
                            return Boolean.TRUE;
                        } else if (Boolean.FALSE.equals(comparefirst)
                                   && Boolean.FALSE.equals(comparelast)) {
                            it = index.findFirstRow(session, store, data);


                            return Boolean.FALSE;
                        } else {
                            return null;
                        }
                    case OpTypes.GREATER :
                        return comparefirst;


                    case OpTypes.GREATER_EQUAL :
                    case OpTypes.GREATER_EQUAL_PRE :
                        return comparefirst;


                    case OpTypes.SMALLER :
                        return comparelast;


                    case OpTypes.SMALLER_EQUAL :
                        return comparelast;
                }


                break;
            }
            case OpTypes.ALL_QUANTIFIED : {
                if (empty) {
                    return Boolean.TRUE;
                }


                if (countNulls(data) == data.length) {
                    return null;
                }


                it        = index.firstRow(session, store, 0);
                firstrow  = it.getNextRow();
                firstdata = firstrow.getData();


                if (countNulls(firstdata) == data.length) {
                    return null;
                }


                convertToType(session, data, nodes[LEFT].nodeDataTypes,
                              nodes[RIGHT].nodeDataTypes);


                it = index.findFirstRow(session, store, data);


                if (opType == OpTypes.EQUAL) {
                    if (it.hasNext()) {
                        return store.elementCount(session) == 1 ? Boolean.TRUE
                                                                : Boolean
                                                                .FALSE;
                    } else {
                        return Boolean.FALSE;
                    }
                }


                if (opType == OpTypes.NOT_EQUAL) {
                    return it.hasNext() ? Boolean.FALSE
                                        : Boolean.TRUE;
                }


                lastrow  = index.lastRow(session, store, 0).getNextRow();
                lastdata = lastrow.getData();

View Full Code Here

            tableSpace = cache.spaceManager.getTableSpace(
                DataSpaceManager.tableIdDefault);


            IndexAVL    idx      = (IndexAVL) indexList[0];
            NodeAVL     root     = (NodeAVL) accessorList[0];
            RowIterator iterator = table.rowIterator(this);


            ArrayUtil.fillArray(accessorList, null);
            elementCount.set(0);


            isCached = true;


            cache.adjustStoreCount(1);


            while (iterator.hasNext()) {
                Row row = iterator.getNextRow();
                Row newRow = (Row) getNewCachedObject(session, row.getData(),
                                                      false);


                indexRow(session, newRow);
            }

View Full Code Here


        for (int i = 1; i < indexList.length; i++) {
            setAccessor(indexList[i], null);
        }


        RowIterator it = rowIterator();


        while (it.hasNext()) {
            Row row = it.getNextRow();


            ((RowAVL) row).clearNonPrimaryNodes();


            for (int i = 1; i < indexList.length; i++) {
                indexList[i].insert(session, this, row);

View Full Code Here

            oldtype = ((Table) other.getTable()).getColumnTypes()[colindex];
        }


        try {
            Table       table = (Table) this.table;
            RowIterator it    = other.rowIterator();


            while (it.hasNext()) {
                Row      row      = it.getNextRow();
                Object[] olddata  = row.getData();
                Object[] data     = table.getEmptyRowData();
                Object   oldvalue = null;


                if (adjust == 0 && colindex != -1) {
                    oldvalue = olddata[colindex];
                    colvalue = newtype.convertToType(session, oldvalue,
                                                     oldtype);
                }


                ArrayUtil.copyAdjustArray(olddata, data, colvalue, colindex,
                                          adjust);
                table.systemSetIdentityColumn(session, data);


                if (table.hasGeneratedColumn()) {
                    ((Table) table).setGeneratedColumns(session, data);
                }


                table.enforceTypeLimits(session, data);
                table.enforceRowConstraints(session, data);


                // get object without RowAction
                Row newrow = (Row) getNewCachedObject(session, data, false);


                indexRow(session, newrow);
            }


            if (table.isTemp()) {
                return;
            }


            if (oldtype != null && oldtype.isLobType()) {
                it = other.rowIterator();


                while (it.hasNext()) {
                    Row      row      = it.getNextRow();
                    Object[] olddata  = row.getData();
                    Object   oldvalue = olddata[colindex];


                    if (oldvalue != null) {
                        session.sessionData.adjustLobUsageCount(oldvalue, -1);
                    }
                }
            }


            if (newtype != null && newtype.isLobType()) {
                it = rowIterator();


                while (it.hasNext()) {
                    Row      row   = it.getNextRow();
                    Object[] data  = row.getData();
                    Object   value = data[colindex];


                    if (value != null) {
                        session.sessionData.adjustLobUsageCount(value, +1);

View Full Code Here


    public void reindex(Session session, Index index) {


        setAccessor(index, null);


        RowIterator it = table.rowIterator(this);


        while (it.hasNext()) {
            RowAVL row = (RowAVL) it.getNextRow();


            row.getNode(index.getPosition()).delete();
            index.insert(session, this, row);
        }
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.hsqldb.navigator.RowIterator

org.hsqldb.Constraint

org.hsqldb.ExpressionLogical

org.hsqldb.index.IndexAVL

org.hsqldb.persist.DataFileDefrag

org.hsqldb.persist.RowStoreAVL

org.hsqldb.persist.RowStoreAVLDisk

org.hsqldb.persist.RowStoreAVLHybrid

org.hsqldb.persist.RowStoreAVLHybridExtended

org.hsqldb.persist.RowStoreAVLMemory

org.hsqldb.RangeVariable$FullRangeIterator

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.