public override IEnumerable<int> SelectRange(IndexRange[] ranges) { int setSize = Table.RowCount; // If no items in the set return an empty set if (setSize == 0) return new List<int>(0); var checker = new RangeChecker(this, ranges); return checker.Resolve(); }
public override IEnumerable<int> SelectRange(IndexRange[] ranges) { // If no items in the set return an empty set if (Count == 0) return new List<int>(0); IEnumerable<int> list = null; foreach (var range in ranges) { list = AddRange(range, list); } if (list == null) return new List<int>(0); return list; }
private static IndexRange IntersectOn(IndexRange range, SqlExpressionType op, Field value, bool nullCheck) { var start = range.StartValue; var startPosition = range.StartOffset; var end = range.EndValue; var endPosition = range.EndOffset; bool inclusive = op == SqlExpressionType.Is || op == SqlExpressionType.Equal || op == SqlExpressionType.GreaterOrEqualThan || op == SqlExpressionType.SmallerOrEqualThan; if (op == SqlExpressionType.Is || op == SqlExpressionType.Equal || op == SqlExpressionType.GreaterThan || op == SqlExpressionType.GreaterOrEqualThan) { // With this operator, NULL values must return null. if (nullCheck && value.IsNull) { return IndexRange.Null; } if (start.Equals(IndexRange.FirstInSet)) { start = value; startPosition = inclusive ? RangeFieldOffset.FirstValue : RangeFieldOffset.AfterLastValue; } else { int c = value.CompareTo(start); if ((c == 0 && startPosition == RangeFieldOffset.FirstValue) || c > 0) { start = value; startPosition = inclusive ? RangeFieldOffset.FirstValue : RangeFieldOffset.AfterLastValue; } } } if (op == SqlExpressionType.Is || op == SqlExpressionType.Equal || op == SqlExpressionType.SmallerThan || op == SqlExpressionType.SmallerOrEqualThan) { // With this operator, NULL values must return null. if (nullCheck && value.IsNull) { return IndexRange.Null; } // If start is first in set, then we have to change it to after NULL if (nullCheck && start.Equals(IndexRange.FirstInSet)) { start = Field.Null(); startPosition = RangeFieldOffset.AfterLastValue; } if (end.Equals(IndexRange.LastInSet)) { end = value; endPosition = inclusive ? RangeFieldOffset.LastValue : RangeFieldOffset.BeforeFirstValue; } else { int c = value.CompareTo(end); if ((c == 0 && endPosition == RangeFieldOffset.LastValue) || c < 0) { end = value; endPosition = inclusive ? RangeFieldOffset.LastValue : RangeFieldOffset.BeforeFirstValue; } } } // If start and end are not null types (if either are, then it means it // is a placeholder value meaning start or end of set). if (!start.Equals(IndexRange.FirstInSet) && !end.Equals(IndexRange.LastInSet)) { // If start is higher than end, return null int c = start.CompareTo(end); if ((c == 0 && (startPosition == RangeFieldOffset.AfterLastValue || endPosition == RangeFieldOffset.BeforeFirstValue)) || c > 0) { return IndexRange.Null; } } // The new intersected range return new IndexRange(startPosition, start, endPosition, end); }
/// <summary> /// Returns true if the two SelectableRange ranges intersect. /// </summary> private static bool IntersectedBy(IndexRange range1, IndexRange range2) { var startFlag1 = range1.StartOffset; var start1 = range1.StartValue; var endFlag1 = range1.EndOffset; var end1 = range1.EndValue; var startFlag2 = range2.StartOffset; var start2 = range2.StartValue; var endFlag2 = range2.EndOffset; var end2 = range2.EndValue; var startCell1 = start1.Equals(IndexRange.FirstInSet) ? null : start1; var endCell1 = end1.Equals(IndexRange.LastInSet) ? null : end1; var startCell2 = start2.Equals(IndexRange.FirstInSet) ? null : start2; var endCell2 = end2.Equals(IndexRange.LastInSet) ? null : end2; bool intersect1 = false; if (startCell1 != null && endCell2 != null) { int c = startCell1.CompareTo(endCell2); if (c < 0 || (c == 0 && (startFlag1 == RangeFieldOffset.FirstValue || endFlag2 == RangeFieldOffset.LastValue))) { intersect1 = true; } } else { intersect1 = true; } bool intersect2 = false; if (startCell2 != null && endCell1 != null) { int c = startCell2.CompareTo(endCell1); if (c < 0 || (c == 0 && (startFlag2 == RangeFieldOffset.FirstValue || endFlag1 == RangeFieldOffset.LastValue))) { intersect2 = true; } } else { intersect2 = true; } return (intersect1 && intersect2); }
/// <summary> /// Alters the first range so it encompasses the second range. /// </summary> /// <remarks> /// This assumes that range1 intersects range2. /// </remarks> private static IndexRange ChangeRangeSizeToEncompass(IndexRange range1, IndexRange range2) { var startPosition1 = range1.StartOffset; var start1 = range1.StartValue; var endPosition1 = range1.EndOffset; var end1 = range1.EndValue; var startPosition2 = range2.StartOffset; var start2 = range2.StartValue; var endPosition2 = range2.EndOffset; var end2 = range2.EndValue; if (!start1.Equals(IndexRange.FirstInSet)) { if (!start2.Equals(IndexRange.FirstInSet)) { var cell = start1; int c = cell.CompareTo(start2); if (c > 0 || c == 0 && startPosition1 == RangeFieldOffset.AfterLastValue && startPosition2 == RangeFieldOffset.FirstValue) { start1 = start2; startPosition1 = startPosition2; } } else { start1 = start2; startPosition1 = startPosition2; } } if (!end1.Equals(IndexRange.LastInSet)) { if (!end2.Equals(IndexRange.LastInSet)) { var cell = end1; int c = cell.CompareTo(end2); if (c < 0 || c == 0 && endPosition1 == RangeFieldOffset.BeforeFirstValue && endPosition2 == RangeFieldOffset.LastValue) { end1 = end2; endPosition1 = endPosition2; } } else { end1 = end2; endPosition1 = endPosition2; } } return new IndexRange(startPosition1, start1, endPosition1, end1); }
private IEnumerable<int> AddRange(IndexRange range, IEnumerable<int> list) { // Select the range specified. var startFlag = range.StartOffset; var start = range.StartValue; var endFlag = range.EndOffset; var end = range.EndValue; int r1 = PositionOfRangePoint(startFlag, start); int r2 = PositionOfRangePoint(endFlag, end); if (r2 < r1) return list; // Add the range to the set return AddRange(r1, r2, list); }
/// <summary> /// Set up a range. /// </summary> /// <param name="i"></param> /// <param name="range"></param> private void SetupRange(int i, IndexRange range) { 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); } }
public RangeChecker(BlindSearchIndex scheme, IndexRange[] ranges) { 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]); } }
public static ITable SelectRange(this ITable thisTable, ObjectName columnName, IndexRange[] ranges) { // If this table is empty then there is no range to select so // trivially return this object. if (thisTable.RowCount == 0) return thisTable; // Are we selecting a black or null range? if (ranges == null || ranges.Length == 0) // Yes, so return an empty table return thisTable.EmptySelect(); // Are we selecting the entire range? if (ranges.Length == 1 && ranges[0].Equals(IndexRange.FullRange)) // Yes, so return this table. return thisTable; // Must be a non-trivial range selection. // Find the column index of the column selected int column = thisTable.IndexOfColumn(columnName); if (column == -1) { throw new Exception( "Unable to find the column given to select the range of: " + columnName.Name); } // Select the range var rows = thisTable.SelectRowsRange(column, ranges); // Make a new table with the range selected var result = new VirtualTable(thisTable, rows.ToArray()); // We know the new set is ordered by the column. result.SortColumn = column; return result; }
public static IEnumerable<int> SelectRowsRange(this ITable table, int column, IndexRange[] ranges) { return table.GetIndex(column).SelectRange(ranges); }
public override IEnumerable<int> SelectRange(IndexRange[] ranges) { throw new NotImplementedException(); }