Deveel.Data.Index.BlindSearchIndex.RangeChecker Class Reference

Public Member Functions
	RangeChecker (BlindSearchIndex scheme, IndexRange[] ranges)
IEnumerable< int >	Resolve ()
	Resolves the ranges. More...

Private Member Functions
void	ResolveSortedSet ()
DataObject	ResolveCell (DataObject ob)
	Resolves a cell. More...
void	SetupRange (int i, IndexRange range)
	Set up a range. More...

Private Attributes
readonly BlindSearchIndex	scheme
IEnumerable< int >	sortedSet
	The sorted list of all items in the set created as a cache for finding the first and last values. More...
readonly byte[]	lowerFlags
readonly byte[]	upperFlags
readonly DataObject[]	lowerCells
readonly DataObject[]	upperCells
const byte	NoCheck = 0
const byte	CheckLesserOrGreater = 1
const byte	CheckLesserEqualOrGreaterEqual = 2

Detailed Description

Definition at line 111 of file BlindSearchIndex.cs.

Constructor & Destructor Documentation

Deveel.Data.Index.BlindSearchIndex.RangeChecker.RangeChecker ( BlindSearchIndex  scheme, IndexRange[]  ranges  )

inline

Definition at line 133 of file BlindSearchIndex.cs.

                                                                              {
                this.scheme = scheme;

                int size = ranges.Length;
                lowerFlags = new byte[size];
                upperFlags = new byte[size];
                lowerCells = new DataObject[size];
                upperCells = new DataObject[size];
                for (int i = 0; i < ranges.Length; ++i) {
                    SetupRange(i, ranges[i]);
                }
            }

Member Function Documentation

IEnumerable<int> Deveel.Data.Index.BlindSearchIndex.RangeChecker.Resolve ( )

inline

Resolves the ranges.

Returns

Definition at line 220 of file BlindSearchIndex.cs.

                                              {
                // The idea here is to only need to scan the column once to find all
                // the cells that meet our criteria.
                var list = new List<int>();
                var e = scheme.Table.GetEnumerator();

                int compareTally = 0;

                int size = lowerFlags.Length;
                while (e.MoveNext()) {
                    int row = e.Current.RowId.RowNumber;
                    // For each range
                    for (int i = 0; i < size; ++i) {
                        bool result = true;
                        byte lf = lowerFlags[i];
                        if (lf != NoCheck) {
                            ++compareTally;
                            var v = scheme.GetValue(row);
                            int compare = lowerCells[i].CompareTo(v);
                            if (lf == CheckLesserOrGreater) {  // >
                                result = (compare < 0);
                            } else if (lf == CheckLesserEqualOrGreaterEqual) {  // >=
                                result = (compare <= 0);
                            } else {
                                throw new InvalidOperationException("Incorrect flag.");
                            }
                        }
                        if (result) {
                            byte uf = upperFlags[i];
                            if (uf != NoCheck) {
                                ++compareTally;
                                var v = scheme.GetValue(row);
                                int compare = upperCells[i].CompareTo(v);
                                if (uf == CheckLesserOrGreater) {  // <
                                    result = (compare > 0);
                                } else if (uf == CheckLesserEqualOrGreaterEqual) {  // >=
                                    result = (compare >= 0);
                                } else {
                                    throw new InvalidOperationException("Incorrect flag.");
                                }
                            }
                            // Pick this row
                            if (result) {
                                scheme.DoInsertSort(list, row);
                                break;
                            }
                        }
                    }
                }

                return list.AsEnumerable();
            }

DataObject Deveel.Data.Index.BlindSearchIndex.RangeChecker.ResolveCell ( DataObject  ob )

inlineprivate

Resolves a cell.

Parameters

ob

Returns

Definition at line 157 of file BlindSearchIndex.cs.

                                                          {
                if (ob.Equals(IndexRange.FirstInSet)) {
                    ResolveSortedSet();
                    return scheme.GetValue(sortedSet.First());

                }
                if (ob.Equals(IndexRange.LastInSet)) {
                    ResolveSortedSet();
                    return scheme.GetValue(sortedSet.Last());
                }

                return ob;
            }

void Deveel.Data.Index.BlindSearchIndex.RangeChecker.ResolveSortedSet ( )

inlineprivate

Definition at line 146 of file BlindSearchIndex.cs.

                                            {
                if (sortedSet == null) {
                    sortedSet = scheme.SelectAll();
                }
            }

void Deveel.Data.Index.BlindSearchIndex.RangeChecker.SetupRange ( int  i, IndexRange  range  )

inlineprivate

Set up a range.

Parameters

i
range

Definition at line 176 of file BlindSearchIndex.cs.

                                                             {
                var l = range.StartValue;
                var lf = range.StartOffset;
                var u = range.EndValue;
                var uf = range.EndOffset;

                // Handle lower first
                if (l.Equals(IndexRange.FirstInSet) &&
                    lf.Equals(RangeFieldOffset.FirstValue)) {
                    // Special case no lower check
                    lowerFlags[i] = NoCheck;
                } else {
                    if (lf.Equals(RangeFieldOffset.FirstValue)) {
                        lowerFlags[i] = CheckLesserEqualOrGreaterEqual;  // >=
                    } else if (lf.Equals(RangeFieldOffset.AfterLastValue)) {
                        lowerFlags[i] = CheckLesserOrGreater;  // >
                    } else {
                        throw new InvalidOperationException("Incorrect lower flag.");
                    }
                    lowerCells[i] = ResolveCell(l);
                }

                // Now handle upper
                if (u.Equals(IndexRange.LastInSet) &&
                    uf.Equals(RangeFieldOffset.LastValue)) {
                    // Special case no upper check
                    upperFlags[i] = NoCheck;
                } else {
                    if (uf.Equals(RangeFieldOffset.LastValue)) {
                        upperFlags[i] = CheckLesserEqualOrGreaterEqual;  // <=
                    } else if (uf.Equals( RangeFieldOffset.BeforeFirstValue)) {
                        upperFlags[i] = CheckLesserOrGreater;  // <
                    } else {
                        throw new InvalidOperationException("Incorrect upper flag.");
                    }
                    upperCells[i] = ResolveCell(u);
                }

            }

Member Data Documentation

const byte Deveel.Data.Index.BlindSearchIndex.RangeChecker.CheckLesserEqualOrGreaterEqual = 2

private

Definition at line 131 of file BlindSearchIndex.cs.

const byte Deveel.Data.Index.BlindSearchIndex.RangeChecker.CheckLesserOrGreater = 1

private

Definition at line 130 of file BlindSearchIndex.cs.

readonly DataObject [] Deveel.Data.Index.BlindSearchIndex.RangeChecker.lowerCells

private

Definition at line 126 of file BlindSearchIndex.cs.

readonly byte [] Deveel.Data.Index.BlindSearchIndex.RangeChecker.lowerFlags

private

Definition at line 122 of file BlindSearchIndex.cs.

const byte Deveel.Data.Index.BlindSearchIndex.RangeChecker.NoCheck = 0

private

Definition at line 129 of file BlindSearchIndex.cs.

readonly BlindSearchIndex Deveel.Data.Index.BlindSearchIndex.RangeChecker.scheme

private

Definition at line 112 of file BlindSearchIndex.cs.

IEnumerable<int> Deveel.Data.Index.BlindSearchIndex.RangeChecker.sortedSet

private

The sorted list of all items in the set created as a cache for finding the first and last values.

Definition at line 118 of file BlindSearchIndex.cs.

readonly DataObject [] Deveel.Data.Index.BlindSearchIndex.RangeChecker.upperCells

private

Definition at line 127 of file BlindSearchIndex.cs.

readonly byte [] Deveel.Data.Index.BlindSearchIndex.RangeChecker.upperFlags

private

Definition at line 123 of file BlindSearchIndex.cs.

---

The documentation for this class was generated from the following file:

• /var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Index/BlindSearchIndex.cs