public async Task ExecuteNonQuery(string cypherQuery, object queryParams = null)
{
IAsyncSession session = _driver.AsyncSession(o => o.WithDatabase(this._database));
if (queryParams == null)
{
queryParams = new {};
}
try
{
_logger.LogDebug($"Executing query: {cypherQuery}");
IResultCursor cursor = await session.RunAsync(cypherQuery, queryParams);
IResultSummary result = await cursor.ConsumeAsync();
_logger.LogTrace($"Query executed successfully.");
}
catch (Exception ex)
{
Console.WriteLine($"Error executing query. {ex.Message}");
throw;
}
finally
{
await session.CloseAsync();
}
}
public async Task <List <INode> > ConnectDb(string query)
{
Driver = CreateDriverWithBasicAuth("bolt://localhost:7687", "neo4j", "1234");
List <INode> res = new List <INode>();
IAsyncSession session = Driver.AsyncSession(o => o.WithDatabase("neo4j"));
try
{
res = await session.ReadTransactionAsync(async tx =>
{
var results = new List <INode>();
var reader = await tx.RunAsync(query);
while (await reader.FetchAsync())
{
results.Add(reader.Current[0].As <INode>());
}
return(results);
});
}
finally
{
await session.CloseAsync();
}
return(res);
}
public async Task <List <T> > Run <T>(IQuery <T>[] queries, string databaseName, bool defaultDatabase)
{
IAsyncSession session = GetAsyncSession(databaseName, defaultDatabase);
try
{
LogRun("queries", databaseName, defaultDatabase);
var resultToReturn = new List <T>();
foreach (var query in queries)
{
await session.ReadTransactionAsync(async tx =>
{
IResultCursor result = await tx.RunAsync(query.Query);
resultToReturn.AddRange(await result.ToListAsync(query.ProcessRecord));
});
}
return(resultToReturn);
}
finally
{
await session.CloseAsync();
}
}
// Get all records as a List
public async Task <List <T> > FetchRecords <T>(
Func <IRecord, T> recordProcessor,
string cypherQuery,
object queryParams = null)
{
List <T> result = null;
IAsyncSession session = _driver.AsyncSession(o => o.WithDatabase(this._database));
_logger.LogDebug($"Executing query: {cypherQuery}");
if (queryParams == null)
{
queryParams = new {};
}
try
{
IResultCursor resultCursor = await session.RunAsync(cypherQuery, queryParams);
result = await resultCursor.ToListAsync(record => recordProcessor(record));
_logger.LogDebug("Query executed successfully");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error executing query. {ex.Message}");
throw;
}
finally
{
await session.CloseAsync();
}
return(result);
}
public async void CreateActor()
{
// arrange
IAsyncSession session = _neo4JResource.GetAsyncSession();
try
{
// act
var actor = new Actor("Keanu Reaves", 56);
IDictionary <string, object> parameters =
new Neo4jParameters().WithEntity("newActor", actor);
IResultCursor cursor = await session.RunAsync(
@"CREATE (actor:Actor $newActor) RETURN actor",
parameters);
Actor createdActor = await cursor.MapSingleAsync <Actor>();
await cursor.ConsumeAsync();
// assert
createdActor.MatchSnapshot();
}
finally
{
await session.CloseAsync();
}
}
private async Task <bool> pushQueue(Queue <PendingCypher> pendingCyphers, IAsyncSession session, string sessionId)
{
//var pushTasks = new List<Task>();
var wtxResult = await session.WriteTransactionAsync(async tx =>
{
while (pendingCyphers.Count > 0)
{
var pendingQuery = pendingCyphers.Dequeue();
if (pendingQuery.Props != null && pendingQuery.Props.ContainsKey("SessionId"))
{
pendingQuery.Props["SessionId"] = sessionId;
}
var result = await(pendingQuery.Props != null && pendingQuery.Props.Count > 0 ? tx.RunAsync(pendingQuery.Query, pendingQuery.Props) : tx.RunAsync(pendingQuery.Query));
pendingQuery.Complete(result);
//pushTasks.Add(result);
// commitedList.Add(pendingQuery);
}
return(true);
//return Task.WhenAll(pushTasks);
});
return(wtxResult);
}
private static async Task <Response> RunQueryAsync(IAsyncSession session, PlanType planType, Dictionary <string, object> parameters)
{
var query = GetQuery(planType);
var result = await(await session.RunAsync(query, parameters)).ToListAsync();
var plan = result
.Select(r =>
r["nodes"]
.As <List <INode> >()
.Select(n => FormatNode(n))
.ToList())
.FirstOrDefault();
var markers = result
.Select(r =>
r["nodes"]
.As <List <INode> >()
.Where(n => n.Labels.Contains("Stop"))
.Select(n => n["location"].As <Point>())
.Select(p => new LatLng(p.Y, p.X))
.ToArray())
.FirstOrDefault();
if (plan == null)
{
return(null);
}
FormatPlan(plan, planType);
return(new Response(plan.ToArray(), markers));
}
// ############
// RETURN TWO LIST<STRING>
// ############
async void MultipleReturnsTest()
{
// Each IDriver instance maintains a pool of connections inside, as a result, it is recommended to only use one driver per application.
// The driver is thread-safe, while the session or the transaction is not thread-safe.
IDriver driver = GraphDatabase.Driver("neo4j://localhost:7687", AuthTokens.Basic("neo4j", "123456"));
IAsyncSession session = driver.AsyncSession(o => o.WithDatabase("neo4j"));
try
{
IResultCursor cursor = await session.RunAsync("MATCH (a:Person) RETURN a.name, a.born");
// A record is accessible once it is received by the client. It is not needed for the whole result set to be received before it can be visited.
// Each record can only be visited (a.k.a.consumed) once!
// The recommended way to access these result records is to make use of methods provided by ResultCursorExtensions such as SingleAsync,
// ToListAsync, and ForEachAsync.
List <DataHolder> people = await cursor.ToListAsync(record => new DataHolder(record["a.name"].As <string>(), record["a.born"].As <string>()));
await cursor.ConsumeAsync();
foreach (var item in people)
{
Debug.Log(item.ToString());
}
}
finally
{
await session.CloseAsync();
}
await driver.CloseAsync();
}
public async Task InserirNoAsync(string nome, string anilha, string sexo, string nomePopular, string nascimento)
{
session = _driver.AsyncSession(o => o.WithDatabase("neo4j"));//Nome da database está nas propriedades como padrão
string query = String.Empty;
if (sexo != string.Empty)
{
query += ",Sexo:" + "$sexo";
}
if (nomePopular != string.Empty)
{
query += ",NomePopular:" + "$nomePopular";
}
if (nascimento != string.Empty)
{
query += ",Nascimento:" + "$nascimento";
}
try {
if (anilha == string.Empty)
{
cursor = await session.RunAsync("CREATE (p:Passaro{nome:$nome" + query + "})", new { nome, sexo, nomePopular, nascimento });//MERGE Impede cadastro de mesmo nome
}
else
{
cursor = await session.RunAsync("CREATE (p:Passaro{nome:$nome, anilha:$anilha" + query + "})", new { nome, anilha, sexo, nomePopular, nascimento });
}
await cursor.ConsumeAsync();
}
finally {
await session.CloseAsync();
}
}
// ############
// RETURN SINGLE LIST<STRING>
// ############
async void SingleReturnTest()
{
// Each IDriver instance maintains a pool of connections inside, as a result, it is recommended to only use one driver per application.
// The driver is thread-safe, while the session or the transaction is not thread-safe.
IDriver driver = GraphDatabase.Driver("neo4j://localhost:7687", AuthTokens.Basic("neo4j", "123456"));
IAsyncSession session = driver.AsyncSession(o => o.WithDatabase("neo4j"));
try
{
IResultCursor cursor = await session.RunAsync("MATCH (a:Person) RETURN a.name as name");
// The recommended way to access these result records is to make use of methods provided by ResultCursorExtensions such as SingleAsync,
// ToListAsync, and ForEachAsync.
List <string> people = await cursor.ToListAsync(record => record["name"].As <string>());
await cursor.ConsumeAsync();
Debug.Log(people.Count + " single returns");
}
finally
{
await session.CloseAsync();
}
await driver.CloseAsync();
}
// ############
// RETURN SINGLE NODE
// ############
async void SingleNodeLabelsTest()
{
// Each IDriver instance maintains a pool of connections inside, as a result, it is recommended to only use one driver per application.
// The driver is thread-safe, while the session or the transaction is not thread-safe.
IDriver driver = GraphDatabase.Driver("neo4j://localhost:7687", AuthTokens.Basic("neo4j", "123456"));
IAsyncSession session = driver.AsyncSession(o => o.WithDatabase("neo4j"));
try
{
IResultCursor cursor = await session.RunAsync("MATCH (a {name: 'Joel Silver'}) RETURN a");
// The recommended way to access these result records is to make use of methods provided by ResultCursorExtensions such as SingleAsync,
// ToListAsync, and ForEachAsync.
INode person = await cursor.SingleAsync(record => record["a"].As <INode>());
await cursor.ConsumeAsync();
foreach (var item in person.Labels)
{
Debug.Log(item);
}
}
finally
{
await session.CloseAsync();
}
await driver.CloseAsync();
}
public static async Task <List <IRecord> > Query(string query)
{
if (driver is null)
{
throw new ArgumentNullException("Connect to DB before you query");
}
else
{
IAsyncSession session = driver.AsyncSession();
try
{
return(await session.WriteTransactionAsync(tx => RunCypherWithResults(tx, query)));
}
catch (Exception err)
{
// Error
throw err;
}
finally
{
Console.WriteLine("Closed connection");
await session.CloseAsync();
}
}
}
private async Task mnu_ClickAsync(object sender, RoutedEventArgs e)
{
IDriver driver = GraphDatabase.Driver("neo4j://localhost:7687", AuthTokens.Basic("neo4j", "neo4j"));
IAsyncSession session = driver.AsyncSession(o => o.WithDatabase("neo4j"));
try
{
IResultCursor cursor = await session.RunAsync("CREATE (n) RETURN n");
await cursor.ConsumeAsync();
}
finally
{
await session.CloseAsync();
}
await driver.CloseAsync();
///https://stackoverflow.com/questions/59581789/why-does-idriver-not-contain-a-definition-for-session-when-using-neo4j-in-c
///test
/*[TestClass]
* {
* [TestMethod]
* {
* System.Console.WriteLine();
* }
* }*/
}
public IAsyncSession <DuplexMessage> OpenSession(IoSession ioSession)
{
IAsyncSession <DuplexMessage> session = null;
using (var locker = doubleCheckLock.Accquire(
() => sessionMap.TryGetValue(ioSession.RemoteEndPoint.ToString(), out session)))
{
if (locker.Locked)
{
using (var scope = ObjectHost.Host.BeginLifetimeScope())
{
session = scope.Resolve <IAsyncSession <DuplexMessage> >(
new NamedParameter("heartbeatTimeout", HEARTBEAT_TIMEOUT),
new NamedParameter("writerIdleTime", WRITER_IDLE_TIME));
if (session.Open(ioSession))
{
sessionMap[ioSession.RemoteEndPoint.ToString()] = session;
}
else
{
throw new SessionOpenException(ioSession.RemoteEndPoint as IPEndPoint);
}
}
}
else
{
sessionMap.TryRemove(ioSession.RemoteEndPoint.ToString(), out session);
throw new SessionOpenException(ioSession.RemoteEndPoint as IPEndPoint);
}
}
return(session);
}
public IAsyncSession <DuplexMessage> OpenSession()
{
IPEndPoint endpoint = null;
IAsyncSession <DuplexMessage> session = null;
using (var scope = ObjectHost.Host.BeginLifetimeScope())
{
var selector = scope.Resolve <IRemoteEndPointSelector>();
while (selector.TryPick(out endpoint))
{
try
{
session = OpenSession(new ConnectionConfig(endpoint));
if (!session.Connected)
{
selector.MarkDown(endpoint);
session = null;
}
else
{
break;
}
}
catch (Exception)
{
selector.MarkDown(endpoint);
}
}
if (session == null)
{
throw new SessionOpenException(endpoint);
}
return(session);
}
}
private IAsyncSession <DuplexMessage> OpenSession(ConnectionConfig config)
{
IAsyncSession <DuplexMessage> session = null;
using (var locker = doubleCheckLock.Accquire(
() => !sessionMap.TryGetValue(config.EndPoint.ToString(), out session)))
{
if (locker.Locked)
{
using (var scope = ObjectHost.Host.BeginLifetimeScope())
{
session = scope.Resolve <IAsyncSession <DuplexMessage> >(
new NamedParameter("heartbeatTimeout", HEARTBEAT_TIMEOUT),
new NamedParameter("writerIdleTime", WRITER_IDLE_TIME));
session.Open(config);
sessionMap[config.EndPoint.ToString()] = session;
}
}
else
{
if (!session.Connected)
{
sessionMap.TryRemove(config.EndPoint.ToString(), out session);
session = OpenSession(config);
}
}
}
return(session);
}
public async Task <TResult> ExecuteAsync <TResult>(IEnumerable <Query> queries, QueryType queryType, CancellationToken cancellationToken = default)
{
if (queries == null)
{
throw new ArgumentNullException(nameof(queries));
}
if (this.Options.Store == null)
{
throw new InvalidOperationException("No schema builder found.");
}
ISchema schema = this.Options.Store.GetSchema(typeof(TResult));
QueryBuffer buffer = new QueryBuffer(schema, queryType);
await using IAsyncSession connection = this.Options.GetAsyncSession();
foreach (IBatch batch in this.FilterBatches(queries))
{
await foreach (DbDataReader dataReader in connection.ExecuteAsync(batch, cancellationToken).ConfigureAwait(false))
{
await buffer.InsertAsync(dataReader, cancellationToken).ConfigureAwait(false);
}
}
return((TResult)buffer.Commit());
}
private static void InitializeNeo4jConnection(string username, string password, string uri, string database)
{
IDriver driver = GraphDatabase.Driver(uri,
AuthTokens.Basic(username, password));
_session = driver.AsyncSession(o => o.WithDatabase(database));
}
} // stores driver
/// <summary>
/// Connect to database and run a query string
/// </summary>
/// <param name="query">Query to run</param>
/// <returns>Result from database</returns>
public async Task <List <INode> > ConnectDb(string query)
{
// TODO get auth params from some config file
Driver = CreateDriverWithBasicAuth("bolt://localhost:7687", "neo4j", "1234"); // connect to database
List <INode> res = new List <INode>(); // create list to store results in
IAsyncSession session = Driver.AsyncSession(o => o.WithDatabase("neo4j")); // start session
// try to start transaction with query proved. Return results
try {
res = await session.ReadTransactionAsync(async tx => {
var results = new List <INode>();
var reader = await tx.RunAsync(query);
while (await reader.FetchAsync())
{
results.Add(reader.Current[0].As <INode>());
}
return(results); // return results
});
} finally {
await session.CloseAsync(); // close session
}
return(res); // return results
}
public async Task <T> ExecuteScalar <T>(string cypherQuery, object queryParams = null)
{
T result = default(T);
IAsyncSession session = _driver.AsyncSession(o => o.WithDatabase(this._database));
_logger.LogDebug($"Executing query: {cypherQuery}");
if (queryParams == null)
{
queryParams = new {};
}
try
{
IResultCursor resultCursor = await session.RunAsync(cypherQuery, queryParams);
IRecord record = await resultCursor.SingleAsync();
result = record[0].As <T>();
_logger.LogDebug("Query executed successfully");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error executing query. {ex.Message}");
throw;
}
finally
{
await session.CloseAsync();
}
return(result);
}
private static async Task VerifyRunsQuery(IAsyncSession session)
{
var record = await session.RunAndSingleAsync("RETURN 1 AS Number", null);
record.Keys.Should().BeEquivalentTo("Number");
record.Values.Should().BeEquivalentTo(new KeyValuePair <string, object>("Number", 1));
}
public override async Task Process()
{
IAsyncSession session = ((NewSession)ObjManager.GetObject(data.sessionId)).Session;
Bookmarks = session.LastBookmark.Values;
await Task.CompletedTask;
}
public WhenCallingOpenAsyncSession_MultipleTimes()
{
var sessionFactory = new SessionFactory("SqlConnection", new Mock <IDbDriver>().Object, new Mock <ISqlDialect>().Object);
this.session1 = sessionFactory.OpenAsyncSession();
this.session2 = sessionFactory.OpenAsyncSession();
}
public async Task UpsertNodes <T>(IEnumerable <T> nodes, IEnumerable <string> indices = null)
{
IAsyncSession session = AsyncSession();
string objectName = typeof(T).Name.ToLowerInvariant();
string key = null;
try
{
if (!indices.IsNullOrEmpty())
{
key = indices.Select(_ => $"{{{_}:{objectName}.{_}}}").FirstOrDefault();
foreach (var query in indices.Select(_ => $"INDEX ON :{objectName}({_})"))
{
ICypherBuilder cypherBuilder = _cypherBuilderFactory.NewCypherBuilder().AddCreate(query);
await session.RunAsync(cypherBuilder.ToString());
}
}
string cypher = UpsertNodesCypher <T>(key);
await session.WriteTransactionAsync(tx => RunCypher(tx, cypher, new Dictionary <string, object>()
{
{ "nodes", nodes.ToDictionaries() }
}));
}
finally
{
await session.CloseAsync();
}
}
public Neo4j(string connectionString, string username, string password)
{
var uri = new Uri($"bolt://{connectionString}/");
driver = GraphDatabase.Driver(uri, AuthTokens.Basic(username, password));
session = driver.AsyncSession();
}
public BoltNeo4jTransaction(IAsyncSession session, IAsyncTransaction transaction, string database)
{
Database = database;
DriverTransaction = transaction;
Session = session;
IsOpen = true;
Id = Guid.NewGuid();
}
public override async Task Process()
{
IDriver driver = ((NewDriver)ObjManager.GetObject(data.driverId)).Driver;
Session = driver.AsyncSession(SessionConfig);
await Task.CompletedTask;
}
public static IAsyncSession GetSession()
{
IDriver driver = GraphDatabase.Driver("bolt://localhost:7687", AuthTokens.Basic("neo4j", "admin"));
session = driver.AsyncSession();
return(session);
}
/// <summary>
/// Executes a <see cref="IAsyncSession.ReadTransactionAsync{T}(System.Func{IAsyncTransaction,Task{T}})" /> transaction
/// returning the <typeparamref name="T" /> specified.
/// </summary>
/// <remarks>
/// This should be used with queries not returning <see cref="INode" /> values, for example:
/// <c>MATCH (n) RETURN n.title AS title</c>
/// </remarks>
/// <typeparam name="T">The type to attempt to cast to. This should be a class.</typeparam>
/// <param name="session">The <see cref="IAsyncSession" /> to run the transaction on.</param>
/// <param name="query">The query to execute.</param>
/// <param name="parameters">The parameters to the query.</param>
/// <param name="identifier">
/// The identifier to cast into <typeparamref name="T" />. e.g. if the query is
/// <c>MATCH (n) RETURN n.title AS title</c> the identifier is <c>title</c>.
/// </param>
/// <returns>The results of the query.</returns>
public static async Task <IEnumerable <T> > RunReadTransaction <T>(this IAsyncSession session, string query, object parameters, string identifier)
{
Ensure.That(session).IsNotNull();
Ensure.That(query).IsNotNullOrWhiteSpace();
Ensure.That(identifier).IsNotNullOrWhiteSpace();
return(await session.ReadTransactionAsync(tx => ReadTransactionAsList(tx, query, parameters, cursor => cursor.GetValue <T>(identifier))));
}
protected internal static IAsyncSession GetSession(IAsyncSession session)
{
if (session != null && !(session is SessionWrapper))
{
return(new SessionWrapper(session));
}
return(session);
}
public WhenCallingOpenAsyncSession_MultipleTimes()
{
var sessionFactory = new SessionFactory("SqlConnection", new Mock<IDbDriver>().Object, new Mock<ISqlDialect>().Object);
this.session1 = sessionFactory.OpenAsyncSession();
this.session2 = sessionFactory.OpenAsyncSession();
}
public WhenCallingOpenAsyncSession_SpecifyingConnectionScope()
{
var mockDbDriver = new Mock<IDbDriver>();
mockDbDriver.Setup(x => x.CreateConnection()).Returns(new Mock<IDbConnection>().Object);
var mockSqlDialect = new Mock<ISqlDialect>();
mockSqlDialect.Setup(x => x.SqlCharacters).Returns(this.sqlCharacters);
var sessionFactory = new SessionFactory("SqlConnection", mockDbDriver.Object, mockSqlDialect.Object);
this.session = sessionFactory.OpenAsyncSession(ConnectionScope.PerSession);
}
