Examples of org.hsqldb.index.Index

org.hsqldb.index.Index
@author Fred Toussi (fredt@users dot sourceforge.net) @version 1.9.0 @since 1.9.0

    public final Index createAndAddIndexStructure(Session session,
            HsqlName name, int[] columns, boolean[] descending,
            boolean[] nullsLast, boolean unique, boolean constraint,
            boolean forward) {


        Index newindex = createIndexStructure(name, columns, descending,
                                              nullsLast, unique, constraint,
                                              forward);


        addIndex(session, newindex);

View Full Code Here

            cols[j]  = columns[j];
            types[j] = colTypes[cols[j]];
        }


        long id = database.persistentStoreCollection.getNextId();
        Index newIndex = database.logger.newIndex(name, id, this, cols,
            descending, nullsLast, types, false, unique, constraint, forward);


        return newIndex;
    }

View Full Code Here

    final void addIndex(Session session, Index index) {


        int i = 0;


        for (; i < indexList.length; i++) {
            Index current = indexList[i];
            int order = index.getIndexOrderValue()
                        - current.getIndexOrderValue();


            if (order < 0) {
                break;
            }
        }

View Full Code Here

    public final Index createIndex(Session session, HsqlName name,
                                   int[] columns, boolean[] descending,
                                   boolean[] nullsLast, boolean unique,
                                   boolean constraint, boolean forward) {


        Index newIndex = createAndAddIndexStructure(session, name, columns,
            descending, nullsLast, unique, constraint, forward);


        return newIndex;
    }

View Full Code Here

            indexQualifier = tableCatalog;
            indexCount     = table.getIndexCount();


            // process all of the visible indices for this table
            for (int i = 0; i < indexCount; i++) {
                Index index = table.getIndex(i);


                colCount = table.getIndex(i).getColumnCount();


                if (colCount < 1) {
                    continue;
                }


                indexName      = index.getName().name;
                nonUnique      = index.isUnique() ? Boolean.FALSE
                                                  : Boolean.TRUE;
                cardinality    = null;
                pages          = ValuePool.INTEGER_0;
                rowCardinality = null;
                cols           = index.getColumns();
                indexType      = ValuePool.getInt(3);


                for (int k = 0; k < colCount; k++) {
                    col                    = cols[k];
                    row                    = t.getEmptyRowData();

View Full Code Here

    private Boolean getAllAnyValue(Session session, Object[] data,
                                   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();


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

View Full Code Here


            collectIndexableColumns(rangeVariables[i], starts);


            IndexUse[] indexes = table.getIndexForColumns(session,
                colIndexSetEqual, OpTypes.EQUAL, false);
            Index index = null;


            for (int j = 0; j < indexes.length; j++) {
                index = indexes[j].index;


                PersistentStore store = table.getRowStore(session);

View Full Code Here

    }


    private void setEqualityConditions(RangeVariableConditions conditions,
                                       HsqlList exprList, int rangeVarIndex) {


        Index index = null;


        if (rangeVarIndex == 0 && sortAndSlice.usingIndex) {
            index = sortAndSlice.primaryTableIndex;


            if (index != null) {
                conditions.rangeIndex = index;
            }
        }


        if (index == null) {
            IndexUse[] indexes =
                conditions.rangeVar.rangeTable.getIndexForColumns(session,
                    colIndexSetEqual, OpTypes.EQUAL, false);


            if (indexes.length == 0) {
                return;
            }


            index = indexes[0].index;


            double cost = Double.MAX_VALUE;


            if (indexes.length > 1) {
                for (int i = 0; i < indexes.length; i++) {
                    PersistentStore store =
                        conditions.rangeVar.rangeTable.getRowStore(session);
                    double currentCost =
                        store.searchCost(session, indexes[i].index,
                                         indexes[i].columnCount,
                                         OpTypes.EQUAL);


                    if (currentCost < cost) {
                        cost  = currentCost;
                        index = indexes[i].index;
                    }
                }
            }
        }


        int[]        cols                = index.getColumns();
        int          colCount            = cols.length;
        Expression[] firstRowExpressions = new Expression[cols.length];


        for (int j = 0; j < exprList.size(); j++) {
            Expression e = (Expression) exprList.get(j);

View Full Code Here

        if (colIndexSetOther.isEmpty()) {
            return;
        }


        int      currentCount = 0;
        Index    index        = null;
        Iterator it;


        if (rangeVarIndex == 0 && sortAndSlice.usingIndex) {
            index = sortAndSlice.primaryTableIndex;
        }


        if (index == null) {
            it = colIndexSetOther.keySet().iterator();


            while (it.hasNext()) {
                int colIndex = it.nextInt();
                int colCount = colIndexSetOther.get(colIndex, 0);


                if (colCount > currentCount) {
                    Index currentIndex =
                        conditions.rangeVar.rangeTable.getIndexForColumn(
                            session, colIndex);


                    if (currentIndex != null) {
                        index        = currentIndex;

View Full Code Here

                in.addLeftColumnsForAllAny(rangeVar, set);


                IndexUse[] indexes =
                    rangeVar.rangeTable.getIndexForColumns(session, set,
                        OpTypes.EQUAL, false);
                Index index           = indexes[0].index;
                int   indexedColCount = 0;


                for (int j = 0; j < index.getColumnCount(); j++) {
                    if (set.contains(index.getColumns()[j])) {
                        indexedColCount++;
                    } else {
                        break;
                    }
                }


                RangeVariable newRangeVar =
                    new RangeVariable(in.getRightNode().getTable(), null,
                                      null, null, compileContext);


                newRangeVar.isGenerated = true;


                RangeVariable[] newList =
                    new RangeVariable[rangeVariables.length + 1];


                ArrayUtil.copyAdjustArray(rangeVariables, newList,
                                          newRangeVar, i, 1);


                rangeVariables = newList;


                // make two columns as arg
                Expression[] exprList = new Expression[index.getColumnCount()];


                for (int j = 0; j < indexedColCount; j++) {
                    int leftIndex  = index.getColumns()[j];
                    int rightIndex = set.getIndex(leftIndex);
                    Expression e = new ExpressionLogical(rangeVar, leftIndex,
                                                         newRangeVar,
                                                         rightIndex);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.hsqldb.index.Index

org.hsqldb.Constraint

org.hsqldb.dbinfo.DatabaseInformationMain

org.hsqldb.ExpressionLogical

org.hsqldb.ParserDDL

org.hsqldb.persist.RowStoreAVL

org.hsqldb.persist.RowStoreAVLDisk

org.hsqldb.persist.RowStoreAVLHybrid

org.hsqldb.persist.RowStoreAVLMemory

org.hsqldb.QuerySpecification

org.hsqldb.RangeVariable

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.