public string AddTransaction(IAsyncTransaction transation)
{
var key = ProtocolObjectManager.GenerateUniqueIdString();
Transactions.Add(key, transation);
return(key);
}
private static async Task <long> MatchPersonNodeAsync(IAsyncTransaction tx, string name)
{
var result = await tx.RunAsync("MATCH (a:Person {name: $name}) RETURN id(a)", new { name });
return((await result.SingleAsync())[0].As <long>());
}
public BoltNeo4jTransaction(IAsyncSession session, IAsyncTransaction transaction, string database)
{
Database = database;
DriverTransaction = transaction;
Session = session;
IsOpen = true;
Id = Guid.NewGuid();
}
protected internal static IAsyncTransaction GetAsyncTransaction(IAsyncTransaction transaction)
{
if (transaction != null && !(transaction is AsyncTransactionWrapper))
{
return(new AsyncTransactionWrapper(transaction));
}
return(transaction);
}
public static async Task UpdateAsync(this IAsyncTransaction tx, string scope, long value)
{
var parameters = new Dictionary <string, object>
{
{ "scope", scope },
{ "value", value }
};
await tx.RunAsync(Query.Update, parameters).ConfigureAwait(false);
}
private async Task RunCypher(IAsyncTransaction tx, string cypher, Dictionary <string, object> parameters = null)
{
if (parameters != null)
{
await tx.RunAsync(cypher, parameters);
}
else
{
await tx.RunAsync(cypher);
}
}
private static async Task DbCleanup(this IAsyncTransaction transaction)
{
// await transaction.RunAsync(@"
//MATCH (n)
//WHERE NOT (n)<--()
//AND NOT ""Independant"" IN LABELS(n)
//OPTIONAL MATCH(n2:ParentRequired)<--(n)
//OPTIONAL MATCH(n3:ParentRequired)<--(n2)
//DETACH DELETE n, n2, n3
// ");
}
public static async Task InitialiseAsync(this IAsyncTransaction tx)
{
await tx.RunAsync(Query.UniqueScopeConstraint).ConfigureAwait(false);
if (Neo4jOptions.UseNeo4jEnterprise)
{
await tx.RunAsync(Query.ScopeExistsConstraint).ConfigureAwait(false);
await tx.RunAsync(Query.ValueExistsConstraint).ConfigureAwait(false);
}
}
public static async Task <TEntity> GetNodeAsync <TEntity>(
this IAsyncTransaction asyncTransaction,
long nodeId) where TEntity : class
{
var parameters = new Neo4jParameters()
.WithValue("p1", nodeId);
var resultCursor = await asyncTransaction.RunAsync(Constants.Statement.GetNode, parameters)
.ConfigureAwait(false);
return(await resultCursor.MapSingleAsync <TEntity>().ConfigureAwait(false));
}
private void BuildTransaction()
{
lock (locker)
{
if (transaction != null)
{
return;
}
transaction = new SqlAsyncTransaction(connection);
}
}
public Task <T> Work(IAsyncTransaction txc)
{
Interlocked.Increment(ref _invocations);
Thread.Sleep(_delay);
if (_failures.MoveNext())
{
return(Task.FromException <T>(_failures.Current));
}
return(Task.FromResult(_result));
}
public static async Task <long> NextIdAsync(this IAsyncTransaction tx, string scope)
{
var parameters = new Dictionary <string, object>
{
{ "scope", scope }
};
var cursor = await tx.RunAsync(Query.NextId, parameters).ConfigureAwait(false);
var record = await cursor.SingleAsync().ConfigureAwait(false);
return(record[0].As <long>());
}
//TODO: Who uses this constructor??
public BoltNeo4jTransaction(Version version, IDriver driver, IEnumerable <string> bookmarks, string database, bool isWrite = true)
{
Database = database;
Bookmarks = bookmarks?.ToList();
Session = driver.AsyncSession(version, database, isWrite, Bookmarks);
var tx = Session.BeginTransactionAsync();
tx.Wait();
DriverTransaction = tx.Result;
IsOpen = true;
Id = Guid.NewGuid();
}
private async Task <int> SelectEmployee(IAsyncTransaction tx, string name)
{
try
{
var result = await tx.RunAsync("SELECT * FROM Employees WHERE name = $name", new { name });
return((await result.SingleAsync())["employee_number"].As <int>());
}
catch (ClientException ex)
{
Output.WriteLine(ex.Message);
return(-1);
}
}
private async Task <List <IRecord> > RunCypherWithResults(IAsyncTransaction tx, string cypher, Dictionary <string, object> parameters = null)
{
IResultCursor result;
if (parameters != null)
{
result = await tx.RunAsync(cypher, parameters);
}
else
{
result = await tx.RunAsync(cypher);
}
return(await result?.ToListAsync());
}
internal static async Task <List <T> > ReadTransactionAsList <T>(this IAsyncTransaction tx, string query, object parameters, Func <IResultCursor, T> conversionFunction)
{
var cursor = await tx.RunAsync(query, parameters);
var fetched = await cursor.FetchAsync();
var output = new List <T>();
while (fetched)
{
output.Add(conversionFunction(cursor));
fetched = await cursor.FetchAsync();
}
return(output);
}
public static async Task <IResultCursor> SetNodeAsync <TEntity>(
this IAsyncTransaction asyncTransaction,
TEntity entity) where TEntity : class
{
var nodeId = EntityAccessor.GetNodeId(entity);
if (nodeId == null)
{
throw new InvalidOperationException(Constants.NodeIdUnspecifiedMessage);
}
var parameters = new Neo4jParameters()
.WithValue("p1", nodeId)
.WithEntity("p2", entity);
return(await asyncTransaction.RunAsync(Constants.Statement.SetNode, parameters)
.ConfigureAwait(false));
}
public override async Task Process()
{
try
{
var sessionContainer = (NewSession)ObjManager.GetObject(data.sessionId);
await sessionContainer.Session.ReadTransactionAsync(async t =>
{
Transaction = t;
await AysncVoidReturn();
});
//TODO.... it looks like the go backend processes further messages to handle a retryable state
//then returns a RetryableDone in amoungst the other returns....talk to peter.
}
catch (Exception ex)
{
throw new Exception($"Failed to Process TransactionRun protocol object, failed with - {ex.Message}");
}
}
public void SetUp()
{
_driver = Substitute.For <IDriver>();
_session = Substitute.For <IAsyncSession>();
_transaction = Substitute.For <IAsyncTransaction>();
_repository = new GraphRepository(new GraphDbSettingsBuilder()
.Build(),
new CypherBuilderFactory(),
_driver);
_driver
.AsyncSession()
.Returns(_session);
_session
.When(_ => _.WriteTransactionAsync(Arg.Any <Func <IAsyncTransaction, Task> >()))
.Do(_ => _.ArgAt <Func <IAsyncTransaction, Task> >(0).Invoke(_transaction));
_session
.When(_ => _.ReadTransactionAsync(Arg.Any <Func <IAsyncTransaction, Task <List <IRecord> > > >()))
.Do(_ => _.ArgAt <Func <IAsyncTransaction, Task <List <IRecord> > > >(0).Invoke(_transaction));
}
public TransactionWrapper(IAsyncTransaction transaction, Func <IResultCursor, Task <string> > resultHandler)
{
Transaction = transaction;
ResultHandler = resultHandler;
}
public static Task<IResultCursor> RunAsync(this IAsyncTransaction transaction, CypherQuery query, IGraphClient gc)
{
return transaction.RunAsync(query.QueryText, query.ToNeo4jDriverParameters(gc));
}
private static Task CreatePersonNodeAsync(IAsyncTransaction tx, string name)
{
return(tx.RunAsync("CREATE (a:Person {name: $name})", new { name }));
}
public static async Task InitialiseUniqueIdsAsync(this IAsyncTransaction transaction)
{
await transaction.InitialiseAsync().ConfigureAwait(false);
}
public static void GetDriverAndSession(out IDriver driver, out IAsyncSession session, out IAsyncTransaction transaction)
{
var mockNode = Substitute.For <INode>();
mockNode["Name"].Returns("Value");
mockNode.Labels.Returns(new List <string> {
"Node"
});
mockNode.Properties.Returns(new Dictionary <string, object> {
{ "Name", "Value" }
});
var mockRecord = Substitute.For <IRecord>();
mockRecord.Keys.Returns(new List <string> {
"Node"
});
mockRecord["Node"].Returns(mockNode);
mockRecord.Values["Node"].Returns(mockNode);
var mockStatementResult = new TestStatementResult(new List <IRecord>(new[] { mockRecord }));
var mockTransaction = Substitute.For <IAsyncTransaction>();
mockTransaction.RunAsync(Arg.Any <string>(), Arg.Any <IDictionary <string, object> >()).Returns(mockStatementResult);
var task = Task.FromResult(mockTransaction);
task.Result.Should().NotBe(null);
var mockSession = Substitute.For <IAsyncSession>();
var dbmsReturn = GetDbmsComponentsResponse();
mockSession.RunAsync("CALL dbms.components()").Returns(dbmsReturn);
mockSession.BeginTransactionAsync().Returns(Task.FromResult(mockTransaction));
mockSession.BeginTransactionAsync(Arg.Any <Action <TransactionConfigBuilder> >()).Returns(Task.FromResult(mockTransaction));
var mockDriver = Substitute.For <IDriver>();
mockDriver.AsyncSession().Returns(mockSession);
mockDriver.AsyncSession(Arg.Any <Action <SessionConfigBuilder> >()).Returns(mockSession);
driver = mockDriver;
session = mockSession;
transaction = mockTransaction;
}
internal NeoTransactionContext(IDriver driver, NeoContextEngine executingEngine, IAsyncTransaction transaction) : base(driver, executingEngine)
{
this.transaction = transaction;
}
public static async Task UpdateUniqueIdAsync(this IAsyncTransaction transaction, string scope, long value)
{
await transaction.UpdateAsync(scope, value).ConfigureAwait(false);
}
public static async Task <long> NextUniqueIdAsync(this IAsyncTransaction transaction, string scope)
{
return(await transaction.NextIdAsync(scope).ConfigureAwait(false));
}
public InternalRxTransaction(IAsyncTransaction transaction)
{
_transaction = transaction;
}
public static void GetAndConnectGraphClient(out IGraphClient graphClient, out IDriver driver, out IAsyncSession session, out IAsyncTransaction transaction)
{
GetDriverAndSession(out driver, out session, out transaction);
var client = new BoltGraphClient(driver);
client.ConnectAsync().Wait();
driver.ClearReceivedCalls();
session.ClearReceivedCalls();
graphClient = client;
}
