public static void IndexKeyNotEqualsFirstInSet()
{
var firstInSet = IndexRange.FirstInSet;
var key = new IndexKey(new [] { SqlObject.BigInt(33), SqlObject.Double(54) });
Assert.NotEqual(firstInSet, key);
}
private long HighestSearch(IndexKey ob, BigList <long> list, long lower, long higher)
{
if ((higher - lower) <= 5)
{
// Start from the bottom up until we find the highest val
for (var i = higher; i >= lower; --i)
{
int res = ob.CompareTo(GetKey(list[i]));
if (res >= 0)
{
return(i + 1);
}
}
// Didn't find return lowest
return(lower);
}
var mid = (lower + higher) / 2;
int compResult = ob.CompareTo(GetKey(list[mid]));
if (compResult == 0)
{
// We know the bottom is between 'mid' and 'higher'
return(HighestSearch(ob, list, mid, higher));
}
if (compResult < 0)
{
return(HighestSearch(ob, list, lower, mid - 1));
}
return(HighestSearch(ob, list, mid + 1, higher));
}
public static void CompareSingleValue(object value1, object value2, int expetced)
{
var key1 = new IndexKey(SqlObject.New(SqlValueUtil.FromObject(value1)));
var key2 = new IndexKey(SqlObject.New(SqlValueUtil.FromObject(value2)));
Assert.Equal(expetced, key1.CompareTo(key2));
}
public static void SingleValueKeyEqual(object value1, object value2, bool expected)
{
var key1 = new IndexKey(SqlObject.New(SqlValueUtil.FromObject(value1)));
var key2 = new IndexKey(SqlObject.New(SqlValueUtil.FromObject(value2)));
Assert.Equal(expected, key1.Equals(key2));
}
/// <summary>
/// Constructs the range given a start and an end location
/// </summary>
/// <param name="startOffset">The offset of the first value of the range.</param>
/// <param name="firstValue">The first value of the range</param>
/// <param name="lastOffset">The offset within the range of the last value.</param>
/// <param name="endValue">The last value of the range.</param>
public IndexRange(RangeFieldOffset startOffset, IndexKey firstValue, RangeFieldOffset lastOffset,
IndexKey endValue)
: this(false) {
StartOffset = startOffset;
StartValue = firstValue;
EndOffset = lastOffset;
EndValue = endValue;
}
public static IEnumerable <long> SelectEqual(this IIndex index, IndexKey key)
{
if (key.IsNull)
{
return(new long[0]);
}
return(index.SelectRange(new IndexRange(
RangeFieldOffset.FirstValue, key,
RangeFieldOffset.LastValue, key)));
}
public static IEnumerable <long> SelectLess(this IIndex index, IndexKey key)
{
if (key.IsNull)
{
return(new long[0]);
}
return(index.SelectRange(new IndexRange(
RangeFieldOffset.AfterLastValue, key.NullKey,
RangeFieldOffset.BeforeFirstValue, key)));
}
public static void MultiValueKeyEqualToNull(object value1, object value2)
{
var key1 = new IndexKey(new[] {
SqlObject.New(SqlValueUtil.FromObject(value1)),
SqlObject.New(SqlValueUtil.FromObject(value2))
});
var key2 = key1.NullKey;
Assert.NotEqual(key1, key2);
Assert.True(key2.IsNull);
}
public static IEnumerable <long> SelectGreater(this IIndex index, IndexKey key)
{
if (key.IsNull)
{
return(new long[0]);
}
return(index.SelectRange(
new IndexRange(
RangeFieldOffset.AfterLastValue, key,
RangeFieldOffset.LastValue, IndexRange.LastInSet)));
}
public static IEnumerable <long> SelectBetween(this IIndex index, IndexKey key1, IndexKey key2)
{
if (key1.IsNull ||
key2.IsNull)
{
return(new long[0]);
}
return(index.SelectRange(new IndexRange(
RangeFieldOffset.FirstValue, key1,
RangeFieldOffset.BeforeFirstValue, key2)));
}
public IndexRangeSet Intersect(SqlExpressionType op, IndexKey value)
{
lock (this) {
int sz = ranges.Count;
var list = ranges.GetRange(0, sz);
if (op == SqlExpressionType.NotEqual ||
op == SqlExpressionType.IsNot)
{
bool nullCheck = op == SqlExpressionType.NotEqual;
int j = 0;
while (j < sz)
{
var range = list[j];
var leftRange = IntersectOn(range, SqlExpressionType.LessThan, value, nullCheck);
var rightRange = IntersectOn(range, SqlExpressionType.GreaterThan, value, nullCheck);
list.RemoveAt(j);
if (leftRange != IndexRange.Null)
{
list.Add(leftRange);
}
if (rightRange != IndexRange.Null)
{
list.Add(rightRange);
}
j++;
}
return(new IndexRangeSet(list));
}
else
{
bool nullCheck = op != SqlExpressionType.Is;
int j = 0;
while (j < sz)
{
var range = list[j];
range = IntersectOn(range, op, value, nullCheck);
if (range == IndexRange.Null)
{
list.RemoveAt(j);
}
else
{
list[j] = range;
}
j++;
}
return(new IndexRangeSet(list));
}
}
}
public static void CompareMultipleValue(object value1a, object value1b, object value2a, object value2b, int expetced)
{
var key1 = new IndexKey(new[] {
SqlObject.New(SqlValueUtil.FromObject(value1a)),
SqlObject.New(SqlValueUtil.FromObject(value1b))
});
var key2 = new IndexKey(new[] {
SqlObject.New(SqlValueUtil.FromObject(value2a)),
SqlObject.New(SqlValueUtil.FromObject(value2b))
});
Assert.Equal(expetced, key1.CompareTo(key2));
}
public static void MultiValueKeyEqual(object value1a, object value1b, object value2a, object value2b, bool expected)
{
var key1 = new IndexKey(new [] {
SqlObject.New(SqlValueUtil.FromObject(value1a)),
SqlObject.New(SqlValueUtil.FromObject(value1b))
});
var key2 = new IndexKey(new[] {
SqlObject.New(SqlValueUtil.FromObject(value2a)),
SqlObject.New(SqlValueUtil.FromObject(value2b))
});
Assert.Equal(expected, key1.Equals(key2));
}
private IndexKey ResolveKey(IndexKey key)
{
if (key.Equals(IndexRange.FirstInSet))
{
ResolveSortedSet();
return(index.GetKey(sortedSet[0]));
}
if (key.Equals(IndexRange.LastInSet))
{
ResolveSortedSet();
return(index.GetKey(sortedSet[sortedSet.Length - 1]));
}
return(key);
}
public static IEnumerable <long> SelectNotEqual(this IIndex index, IndexKey key)
{
if (key.IsNull)
{
return(new long[0]);
}
return(index.SelectRange(new[] {
new IndexRange(
RangeFieldOffset.AfterLastValue, key.NullKey,
RangeFieldOffset.BeforeFirstValue, key),
new IndexRange(
RangeFieldOffset.AfterLastValue, key,
RangeFieldOffset.LastValue, IndexRange.LastInSet)
}));
}
protected abstract long SearchLast(IndexKey value);
protected override long SearchLast(IndexKey value)
{
return(list.SearchLast(value, comparer));
}
private long PositionOfRangePoint(RangeFieldOffset position, IndexKey val)
{
long p;
IndexKey cell;
switch (position)
{
case RangeFieldOffset.FirstValue:
if (val.Equals(IndexRange.FirstInSet))
{
return(0);
}
if (val.Equals(IndexRange.LastInSet))
{
// Get the last value and search for the first instance of it.
cell = Last;
}
else
{
cell = val;
}
p = SearchFirst(cell);
// (If value not found)
if (p < 0)
{
return(-(p + 1));
}
return(p);
case RangeFieldOffset.LastValue:
if (val.Equals(IndexRange.LastInSet))
{
return(RowCount - 1);
}
if (val.Equals(IndexRange.FirstInSet))
{
// Get the first value.
cell = First;
}
else
{
cell = val;
}
p = SearchLast(cell);
// (If value not found)
if (p < 0)
{
return(-(p + 1) - 1);
}
return(p);
case RangeFieldOffset.BeforeFirstValue:
if (val.Equals(IndexRange.FirstInSet))
{
return(-1);
}
if (val.Equals(IndexRange.LastInSet))
{
// Get the last value and search for the first instance of it.
cell = Last;
}
else
{
cell = val;
}
p = SearchFirst(cell);
// (If value not found)
if (p < 0)
{
return(-(p + 1) - 1);
}
return(p - 1);
case RangeFieldOffset.AfterLastValue:
if (val.Equals(IndexRange.LastInSet))
{
return(RowCount);
}
if (val.Equals(IndexRange.FirstInSet))
{
// Get the first value.
cell = First;
}
else
{
cell = val;
}
p = SearchLast(cell);
// (If value not found)
if (p < 0)
{
return(-(p + 1));
}
return(p + 1);
default:
throw new InvalidOperationException("Unrecognised position.");
}
}
private static IndexRange IntersectOn(IndexRange range, SqlExpressionType op, IndexKey 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.GreaterThanOrEqual ||
op == SqlExpressionType.LessThanOrEqual;
if (op == SqlExpressionType.Is ||
op == SqlExpressionType.Equal ||
op == SqlExpressionType.GreaterThan ||
op == SqlExpressionType.GreaterThanOrEqual)
{
// 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.LessThan ||
op == SqlExpressionType.LessThanOrEqual)
{
// 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 = value.NullKey;
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));
}
