private IBTreeRange Search()
{
IBTreeRange range = Search(Constraint().GetObject());
QEBitmap bitmap = QEBitmap.ForQE(Constraint().Evaluator());
if (bitmap.TakeGreater())
{
if (bitmap.TakeEqual())
{
return(range.ExtendToLast());
}
IBTreeRange greater = range.Greater();
if (bitmap.TakeSmaller())
{
return(greater.Union(range.Smaller()));
}
return(greater);
}
if (bitmap.TakeSmaller())
{
if (bitmap.TakeEqual())
{
return(range.ExtendToFirst());
}
return(range.Smaller());
}
return(range);
}
public virtual IBTreeRange ExtendToLastOf(IBTreeRange range)
{
var rangeImpl = CheckRangeArgument(range
);
return(NewBTreeRangeSingle(_first, rangeImpl._end));
}
protected virtual IBTreeRange Range(int lower, int upper)
{
IBTreeRange lowerRange = Search(lower);
IBTreeRange upperRange = Search(upper);
return(lowerRange.ExtendToLastOf(upperRange));
}
private void EnsureSingleOccurence(Transaction trans, IObjectInfoCollection col)
{
IEnumerator i = col.GetEnumerator();
while (i.MoveNext())
{
IObjectInfo objectInfo = (IObjectInfo)i.Current;
if (this.ReflectClass() != this._enclosing.ReflectorFor(trans, objectInfo.GetObject
()))
{
continue;
}
object obj = this.ObjectFor(trans, objectInfo);
object fieldValue = this.FieldMetadata().GetOn(trans, obj);
if (fieldValue == null)
{
continue;
}
IBTreeRange range = this.FieldMetadata().Search(trans, fieldValue);
if (range.Size() > 1)
{
throw new UniqueFieldValueConstraintViolationException(this.ClassMetadata().GetName
(), this.FieldMetadata().GetName());
}
}
}
public virtual void TestUnionsMerge()
{
IBTreeRange range = Range(3, 3).Union(Range(7, 7)).Union(Range(4, 4));
AssertIsRangeSingle(range);
BTreeAssert.AssertRange(new int[] { 3, 4, 7 }, range);
}
public virtual void TestIntersectUnionUnion()
{
IBTreeRange union1 = Range(3, 3).Union(Range(7, 9));
IBTreeRange union2 = Range(3, 3).Union(Range(9, 9));
AssertIntersection(new int[] { 3, 9 }, union1, union2);
}
public virtual IBTreeRange Intersect(IBTreeRange range)
{
if (null == range)
{
throw new ArgumentNullException();
}
return(new BTreeRangeUnionIntersect(this).Dispatch(range));
}
private bool Contains(int id)
{
lock (Lock())
{
IBTreeRange range = BTree().SearchRange(Transaction(), id);
return(!range.IsEmpty());
}
}
public static void AssertRange(int[] expectedKeys, IBTreeRange range)
{
Assert.IsNotNull(range);
ExpectingVisitor visitor = ExpectingVisitor.CreateSortedExpectingVisitor(expectedKeys
);
TraverseKeys(range, visitor);
visitor.AssertExpectations();
}
public virtual IBTreeRange Intersect(IBTreeRange range)
{
if (null == range)
{
throw new ArgumentNullException();
}
return new BTreeRangeUnionIntersect(this).Dispatch(range);
}
private void AssertLastPointer(int searchValue, int expectedValue)
{
IBTreeRange single = Search(searchValue);
IBTreeRange smallerRange = single.Smaller();
BTreePointer lastPointer = smallerRange.LastPointer();
Assert.AreEqual(expectedValue, lastPointer.Key());
}
public virtual void TestIntersectSingleUnion()
{
IBTreeRange union = Range(3, 3).Union(Range(7, 9));
IBTreeRange single = Range(4, 7);
AssertIntersection(new int[] { 7 }, union, single);
AssertIntersection(new int[] { 3, 7 }, union, Range(3, 7));
}
public virtual IBTreeRange Union(IBTreeRange other)
{
if (null == other)
{
throw new ArgumentNullException();
}
return(new BTreeRangeUnionUnion(this).Dispatch(other));
}
public static void TraverseKeys(IBTreeRange result, IVisitor4 visitor)
{
IEnumerator i = result.Keys();
while (i.MoveNext())
{
visitor.Visit(i.Current);
}
}
public static void AssertRange(int[] expectedKeys, IBTreeRange range)
{
Assert.IsNotNull(range);
ExpectingVisitor visitor = ExpectingVisitor.CreateSortedExpectingVisitor(expectedKeys
);
TraverseKeys(range, visitor);
visitor.AssertExpectations();
}
public static void TraverseKeys(IBTreeRange result, IVisitor4 visitor)
{
IEnumerator i = result.Keys();
while (i.MoveNext())
{
visitor.Visit(i.Current);
}
}
private BTreePointer GetPointerForKey(int key)
{
IBTreeRange range = Search(key);
IEnumerator pointers = range.Pointers();
Assert.IsTrue(pointers.MoveNext());
BTreePointer pointer = (BTreePointer)pointers.Current;
return(pointer);
}
protected virtual void AssertFieldIndex(int id)
{
IReflectClass claxx = Reflector().ForClass(typeof(TPFieldIndexConsistencyTestCaseBase.Item
));
ClassMetadata classMetadata = FileSession().ClassMetadataForReflectClass(claxx);
FieldMetadata field = classMetadata.FieldMetadataForName(IdFieldName);
IBTreeRange indexRange = field.Search(Trans(), id);
Assert.AreEqual(1, indexRange.Size());
}
public static IBTreeRange Union(BTreeRangeUnion union1, BTreeRangeUnion union2)
{
IEnumerator ranges = union1.Ranges();
IBTreeRange merged = union2;
while (ranges.MoveNext())
{
merged = merged.Union((IBTreeRange)ranges.Current);
}
return(merged);
}
public JoinedLeaf(QCon constraint, IIndexedNodeWithRange leaf1, IBTreeRange range
)
{
if (null == constraint || null == leaf1 || null == range)
{
throw new ArgumentNullException();
}
_constraint = constraint;
_leaf1 = leaf1;
_range = range;
}
public JoinedLeaf(QCon constraint, IIndexedNodeWithRange leaf1, IBTreeRange range
)
{
if (null == constraint || null == leaf1 || null == range)
{
throw new ArgumentNullException();
}
_constraint = constraint;
_leaf1 = leaf1;
_range = range;
}
public virtual void TestSearchingRemoved()
{
int[] keys = new int[] { 3, 4, 7, 9 };
Add(keys);
Remove(4);
IBTreeRange result = Search(4);
Assert.IsTrue(result.IsEmpty());
IBTreeRange range = result.Greater();
BTreeAssert.AssertRange(new int[] { 7, 9 }, range);
}
public virtual void TestUnionWithEmptyDoesNotCreateNewRange()
{
IBTreeRange range = Range(3, 4);
IBTreeRange empty = Range(0, 0);
Assert.AreSame(range, range.Union(empty));
Assert.AreSame(range, empty.Union(range));
IBTreeRange union = range.Union(Range(8, 9));
Assert.AreSame(union, union.Union(empty));
Assert.AreSame(union, empty.Union(union));
}
private BTreeNode Node(int value)
{
IBTreeRange range = Search(value);
IEnumerator i = range.Pointers();
i.MoveNext();
BTreePointer firstPointer = (BTreePointer)i.Current;
BTreeNode node = firstPointer.Node();
node.DebugLoadFully(SystemTrans());
return(node);
}
public override int AddressForId(int id)
{
IBTreeRange range = _slotTree.SearchRange(Trans(), new IdSlotMapping(id, 0, 0));
IEnumerator pointers = range.Pointers();
if (pointers.MoveNext())
{
BTreePointer pointer = (BTreePointer)pointers.Current;
return(((IdSlotMapping)pointer.Key())._address);
}
return(0);
}
public static void AssertSingleElement(Transaction trans, BTree btree, object element
)
{
Assert.AreEqual(1, btree.Size(trans));
IBTreeRange result = btree.SearchRange(trans, element);
ExpectingVisitor expectingVisitor = new ExpectingVisitor(new object[] { element }
);
BTreeAssert.TraverseKeys(result, expectingVisitor);
expectingVisitor.AssertExpectations();
expectingVisitor = new ExpectingVisitor(new object[] { element });
btree.TraverseKeys(trans, expectingVisitor);
expectingVisitor.AssertExpectations();
}
public virtual void TestUnionsOfUnions()
{
IBTreeRange union1 = Range(3, 4).Union(Range(8, 9));
BTreeAssert.AssertRange(new int[] { 3, 4, 9 }, union1);
BTreeAssert.AssertRange(new int[] { 3, 4, 7, 9 }, union1.Union(Range(7, 7)));
IBTreeRange union2 = Range(3, 3).Union(Range(7, 7));
AssertUnion(new int[] { 3, 4, 7, 9 }, union1, union2);
AssertIsRangeSingle(union1.Union(union2));
AssertIsRangeSingle(union2.Union(union1));
IBTreeRange union3 = Range(3, 3).Union(Range(9, 9));
AssertUnion(new int[] { 3, 7, 9 }, union2, union3);
}
private Db4objects.Db4o.Internal.Btree.BTreeRangeSingle CheckRangeArgument(IBTreeRange
range)
{
if (null == range)
{
throw new ArgumentNullException();
}
Db4objects.Db4o.Internal.Btree.BTreeRangeSingle rangeImpl = (Db4objects.Db4o.Internal.Btree.BTreeRangeSingle
)range;
if (Btree() != rangeImpl.Btree())
{
throw new ArgumentException();
}
return(rangeImpl);
}
private BTreeRangeSingle CheckRangeArgument(IBTreeRange
range)
{
if (null == range)
{
throw new ArgumentNullException();
}
var rangeImpl = (BTreeRangeSingle
)range;
if (Btree() != rangeImpl.Btree())
{
throw new ArgumentException();
}
return(rangeImpl);
}
private void ExpectKeysSearch(BTree btree, int[] values)
{
int lastValue = int.MinValue;
for (int i = 0; i < values.Length; i++)
{
if (values[i] != lastValue)
{
ExpectingVisitor expectingVisitor = ExpectingVisitor.CreateExpectingVisitor(values
[i], IntArrays4.Occurences(values, values[i]));
IBTreeRange range = FieldIndexKeySearch(Trans(), btree, values[i]);
BTreeAssert.TraverseKeys(range, new _IVisitor4_62(expectingVisitor));
expectingVisitor.AssertExpectations();
lastValue = values[i];
}
}
}
private void ExpectKeysSearch(Transaction trans, BTree btree, int[] keys)
{
int lastValue = int.MinValue;
for (int i = 0; i < keys.Length; i++)
{
if (keys[i] != lastValue)
{
ExpectingVisitor expectingVisitor = ExpectingVisitor.CreateExpectingVisitor(keys[
i], IntArrays4.Occurences(keys, keys[i]));
IBTreeRange range = btree.SearchRange(trans, keys[i]);
BTreeAssert.TraverseKeys(range, expectingVisitor);
expectingVisitor.AssertExpectations();
lastValue = keys[i];
}
}
}
private IBTreeRange SearchRange(Transaction trans, IPreparedComparison preparedComparison
)
{
EnsureActive(trans);
// TODO: Optimize the following.
// Part of the search operates against the same nodes.
// As long as the bounds are on one node, the search
// should walk the nodes in one go.
BTreeNodeSearchResult start = SearchLeaf(trans, preparedComparison, SearchTarget.
Lowest);
BTreeNodeSearchResult end = SearchLeaf(trans, preparedComparison, SearchTarget.Highest
);
IBTreeRange range = start.CreateIncludingRange(end);
ConvertCacheEvictedNodesToReadMode();
return(range);
}
public HardObjectReference GetHardObjectReferenceBySignature(Transaction transaction
, long longPart, byte[] signature)
{
IBTreeRange range = Search(transaction, longPart);
IEnumerator keys = range.Keys();
while (keys.MoveNext())
{
IFieldIndexKey current = (IFieldIndexKey)keys.Current;
HardObjectReference hardRef = GetHardObjectReferenceById(transaction, current.ParentID
(), signature);
if (null != hardRef)
{
return(hardRef);
}
}
return(HardObjectReference.Invalid);
}
public override int MappedId(int oldID)
{
if (_cache.Orig() == oldID)
{
return(_cache.Mapped());
}
int classID = MappedClassID(oldID);
if (classID != 0)
{
return(classID);
}
IBTreeRange range = _idTree.SearchRange(Trans(), new MappedIDPair(oldID, 0));
IEnumerator pointers = range.Pointers();
if (pointers.MoveNext())
{
BTreePointer pointer = (BTreePointer)pointers.Current;
_cache = (MappedIDPair)pointer.Key();
return(_cache.Mapped());
}
return(0);
}
public virtual IBTreeRange ExtendToLastOf(IBTreeRange range)
{
Db4objects.Db4o.Internal.Btree.BTreeRangeSingle rangeImpl = CheckRangeArgument(range
);
return NewBTreeRangeSingle(_first, rangeImpl._end);
}
public virtual IBTreeRange Union(IBTreeRange other)
{
if (null == other)
{
throw new ArgumentNullException();
}
return new BTreeRangeSingleUnion(this).Dispatch(other);
}
public virtual IBTreeRange ExtendToLastOf(IBTreeRange upperRange)
{
throw new NotImplementedException();
}
private void AssertIntersection(int[] expectedKeys, IBTreeRange range1, IBTreeRange
range2)
{
BTreeAssert.AssertRange(expectedKeys, range1.Intersect(range2));
BTreeAssert.AssertRange(expectedKeys, range2.Intersect(range1));
}
private BTreeRangeSingle CheckRangeArgument(IBTreeRange
range)
{
if (null == range)
{
throw new ArgumentNullException();
}
var rangeImpl = (BTreeRangeSingle
) range;
if (Btree() != rangeImpl.Btree())
{
throw new ArgumentException();
}
return rangeImpl;
}
public void Visit(BTreeRangeUnion union)
{
_resultingRange = Execute(union);
}
private void AssertIsRangeSingle(IBTreeRange range)
{
Assert.IsInstanceOf(typeof(BTreeRangeSingle), range);
}
public virtual IBTreeRange ExtendToLastOf(IBTreeRange range)
{
var rangeImpl = CheckRangeArgument(range
);
return NewBTreeRangeSingle(_first, rangeImpl._end);
}
private Db4objects.Db4o.Internal.Btree.BTreeRangeSingle CheckRangeArgument(IBTreeRange
range)
{
if (null == range)
{
throw new ArgumentNullException();
}
Db4objects.Db4o.Internal.Btree.BTreeRangeSingle rangeImpl = (Db4objects.Db4o.Internal.Btree.BTreeRangeSingle
)range;
if (Btree() != rangeImpl.Btree())
{
throw new ArgumentException();
}
return rangeImpl;
}
private void AssertUnion(int[] expectedKeys, IBTreeRange range1, IBTreeRange range2
)
{
BTreeAssert.AssertRange(expectedKeys, range1.Union(range2));
BTreeAssert.AssertRange(expectedKeys, range2.Union(range1));
}
private void AssertSize(int size, IBTreeRange range)
{
Assert.AreEqual(size, range.Size());
}
public IndexedLeaf(QConObject qcon) : base(qcon)
{
_range = Search();
}
public virtual IBTreeRange Dispatch(IBTreeRange range)
{
range.Accept(this);
return _resultingRange;
}
public void Visit(BTreeRangeSingle single)
{
_resultingRange = Execute(single);
}
