public bool GraphIsTracked(InternalId internalId)
{
return
GetCurrentPersistenceEvents()
.Where(_ => _.InternalId == internalId)
.Any();
}
protected override void Given()
{
stashedPost = new Post
{
Title = "My Super Blog",
PostedAt = new DateTime(2010, 03, 19, 13, 33, 34),
Text = "This is my super blog. Check out my awesome post",
Comments = new List<Comment>
{
new Comment
{
Author = "Andy Hitchman",
AuthorsEmail = "*****@*****.**",
CommentedAt = new DateTime(2010, 03, 19, 13, 36, 01),
Text = "This blog is teh suck"
}
}
};
var internalId = new InternalId(Guid.NewGuid());
var registeredGraph = Kernel.Registry.GetRegistrationFor<Post>();
var serializedGraph = registeredGraph.Serialize(stashedPost, null);
var projectedIndexes = registeredGraph.IndexersOnGraph.SelectMany(_ => _.GetUntypedProjections(stashedPost));
var tracked = new TrackedGraph(new StoredGraph(internalId, registeredGraph.GraphType, serializedGraph), projectedIndexes, registeredGraph);
Kernel.Registry.BackingStore.InTransactionDo(_ => _.InsertGraph(tracked));
}
public void it_should_return_the_internal_id_if_the_graph_is_tracked()
{
var mockPersistentEvent = MockRepository.GenerateStub<IPersistenceEvent>();
var sut = new SerializationSession(() => new[] {mockPersistentEvent}, null, false);
var expected = new InternalId(Guid.NewGuid());
var graph = new object();
mockPersistentEvent.Stub(_ => _.UntypedGraph).Return(graph);
mockPersistentEvent.Stub(_ => _.InternalId).Return(expected);
sut.InternalIdOfTrackedGraph(graph).ShouldEqual(expected);
}
public static byte[] ValueForKey(this HashDatabase store, InternalId key)
{
try
{
return store.Get(new DatabaseEntry(key.AsByteArray())).Value.Data;
}
catch(NotFoundException)
{
Assert.Fail("ValueForKey: Key not found");
}
return null;
}
protected override void Given()
{
lhs = MockRepository.GenerateStub<IBerkeleyQuery>();
rhs = MockRepository.GenerateStub<IBerkeleyQuery>();
var commonGuid = new InternalId(Guid.NewGuid());
lhsSet = new[] {commonGuid, new InternalId(Guid.NewGuid())};
rhsSet = new[] {new InternalId(Guid.NewGuid()), commonGuid};
lhs.Stub(_ => _.Execute(null)).IgnoreArguments().Return(lhsSet);
rhs.Stub(_ => _.Execute(null)).IgnoreArguments().Return(rhsSet);
sut = new UnionOperator(new[] {lhs, rhs});
}
protected override void Given()
{
lhs = Substitute.For<IAzureQuery>();
rhs = Substitute.For<IAzureQuery>();
intersectingGuid1 = new InternalId(Guid.NewGuid());
intersectingGuid2 = new InternalId(Guid.NewGuid());
lhs.ExecuteInsideIntersect(null, null).ReturnsForAnyArgs(new[] {intersectingGuid1});
rhs.ExecuteInsideIntersect(null, null).ReturnsForAnyArgs(new[] {intersectingGuid2});
sut = new UnionOperator(new[] {lhs, rhs});
joinConstraint = new[]
{
intersectingGuid1, new InternalId(Guid.NewGuid()), intersectingGuid2
};
}
protected override void Given()
{
lhs = MockRepository.GenerateStub<IBerkeleyQuery>();
rhs = MockRepository.GenerateStub<IBerkeleyQuery>();
commonGuid = new InternalId(Guid.NewGuid());
lhsSet = new[] {commonGuid, new InternalId(Guid.NewGuid())};
rhsSet = new[] {new InternalId(Guid.NewGuid()), commonGuid};
//A bit weak. We're not sure which side will execute first: The second to execute
//will call ExecuteInsideIntersect. Cheat by ignoring this and having the pair of methods
//return the same result.
lhs.Stub(_ => _.Execute(null)).IgnoreArguments().Return(lhsSet);
lhs.Stub(_ => _.ExecuteInsideIntersect(null, null)).IgnoreArguments().Return(lhsSet);
rhs.Stub(_ => _.Execute(null)).IgnoreArguments().Return(rhsSet);
rhs.Stub(_ => _.ExecuteInsideIntersect(null, null)).IgnoreArguments().Return(rhsSet);
sut = new IntersectOperator(new[] {lhs, rhs});
}
public static void ShouldNotHaveKey(this HashDatabase store, InternalId key)
{
store.Exists(new DatabaseEntry(key.AsByteArray())).ShouldBeFalse();
}
public void Insert(object key, InternalId internalId, TableServiceContext serviceContext)
{
serviceContext.AddObject(ForwardIndexName, new IndexEntity {PartitionKey = KeyAsString(key), RowKey = internalId.ToString(), OriginalValue = key.ToString()});
serviceContext.AddObject(ReverseIndexName, new IndexEntity { PartitionKey = internalId.ToString(), RowKey = KeyAsString(key), OriginalValue = key.ToString() });
}
public void Delete(InternalId internalId, TableServiceContext serviceContext)
{
var allKeysInIndex =
(from ri in ReverseIndex(serviceContext)
where ri.PartitionKey == internalId.ToString()
select ri);
//In the forward index, get the corresponding forward index for each reverse index value and delete them both
Parallel.ForEach(
allKeysInIndex,
reverseEntity =>
{
// var forwardEntity = new IndexEntity {PartitionKey = reverseEntity.RowKey, RowKey = reverseEntity.PartitionKey};
// serviceContext.AttachTo(ForwardIndexName, forwardEntity, "*");
var forwardEntity =
Queryable.Single<IndexEntity>((from fi in ForwardIndex(serviceContext)
where fi.PartitionKey == reverseEntity.RowKey
where fi.RowKey == reverseEntity.PartitionKey
select fi));
serviceContext.DeleteObject(forwardEntity);
serviceContext.DeleteObject(reverseEntity);
});
}
public IEnumerable<InternalId> Execute(TableServiceContext serviceContext)
{
var query = managedIndex.ReverseIndex(serviceContext);
Func<InternalId, InternalId> nextInternalId =
cid =>
{
var next =
(from ri in query
where ri.PartitionKey.CompareTo(cid.Value.ToString()) > 0
select ri)
.FirstOrDefault();
return next != null ? managedIndex.ConvertToInternalId(next.PartitionKey) : null;
};
var currentInternalId = new InternalId(Guid.Empty);
while ((currentInternalId = nextInternalId(currentInternalId)) != null)
yield return currentInternalId;
}
/// <summary>
/// Get the graph by internal id. If the graph is not tracked, it is fetched from the
/// backing store and tracked.
/// </summary>
/// <param name = "internalId"></param>
/// <returns></returns>
/// <exception cref = "GraphForKeyNotFoundException">If the graph is not persisted in the backing store.</exception>
public object TrackedGraphForInternalId(InternalId internalId)
{
if(ActivelyDeserialising.ContainsKey(internalId))
return ActivelyDeserialising[internalId];
var tracked =
GetCurrentPersistenceEvents()
.Where(_ => _.InternalId == internalId)
.Select(_ => _.UntypedGraph).FirstOrDefault();
if(tracked != null)
return tracked;
var loading = InternalSession.LoadTrackedGraphForInternalId(internalId, this, untracked);
return loading;
}
public void RecordActiveDeserialization(InternalId internalId, object graph)
{
ActivelyDeserialising.Add(internalId, graph);
}
public StoredGraph(InternalId internalId, Type graphType, Stream graph)
: this(internalId, graphType)
{
SerialisedGraph = graph;
}
public StoredGraph(InternalId internalId, Type graphType)
{
InternalId = internalId;
GraphType = graphType;
}
public void Insert(object untypedKey, InternalId internalId, Transaction transaction)
{
index
.Put(
new DatabaseEntry(KeyAsByteArray(untypedKey)),
new DatabaseEntry(internalId.AsByteArray()),
transaction);
reverseIndex
.Put(
new DatabaseEntry(internalId.AsByteArray()),
new DatabaseEntry(KeyAsByteArray(untypedKey)),
transaction);
}
/// <summary>
/// Create a stored graph based on an existing record
/// </summary>
/// <param name="internalId"></param>
/// <param name="graphType"></param>
/// <param name="accessCondition"> </param>
/// <param name="graph"></param>
public StoredGraph(InternalId internalId, Type graphType, AccessCondition accessCondition, Stream graph)
: this(internalId, graphType, accessCondition)
{
SerialisedGraph = graph;
}
/// <summary>
/// Create a stored graph based on an existing record
/// </summary>
/// <param name="internalId"></param>
/// <param name="graphType"></param>
/// <param name="accessCondition"> </param>
public StoredGraph(InternalId internalId, Type graphType, AccessCondition accessCondition)
{
InternalId = internalId;
GraphType = graphType;
AccessCondition = accessCondition;
}