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); }