public async Task ShouldThrowExceptionIfNullResult()
            {
                IStatementResultCursor result = null;
                var exception = await Record.ExceptionAsync(() => result.SingleAsync());

                exception.Should().BeOfType <ArgumentNullException>();
            }
Ejemplo n.º 2
0
        public async Task <int> DropIndexAsync(string label, string propertyname)
        {
            string query = $"DROP INDEX ON :{label}({propertyname})";
            int    count = 0;

            using (ISession session = this._driver.Session())
            {
                try
                {
                    await session.ReadTransactionAsync(async (tx) =>
                    {
                        IStatementResultCursor reader = await tx.RunAsync(query);
                        await reader.ConsumeAsync();
                        IResultSummary summary = await reader.SummaryAsync();
                        count = summary.Counters.IndexesRemoved;
                    });
                }
                catch (Exception e)
                {
                    this._logger.LogError(e, $"Error dropping index for label {label} on property {propertyname}");
                }
                finally
                {
                    await session.CloseAsync();
                }
            }
            return(count);
        }
Ejemplo n.º 3
0
        private async Task <ExerciseSession> GetExerciseSessionComplete(IStatementResultCursor reader)
        {
            var exerciseSession = new ExerciseSession();

            while (await reader.FetchAsync())
            {
                var exerciseSessionId = Guid.Parse(reader.Current[0].ToString());
                if (exerciseSession.Id != exerciseSessionId)
                {
                    exerciseSession = new ExerciseSession()
                    {
                        Id           = exerciseSessionId,
                        Note         = reader.Current[1]?.ToString(),
                        ExerciseName = reader.Current[2].ToString(),
                        Records      = new List <ExerciseRecord>()
                    };
                }
                exerciseSession.Records.Add(new ExerciseRecord()
                {
                    Id             = Guid.Parse(reader.Current[3].ToString()),
                    EpochTimestamp = double.Parse(reader.Current[4].ToString()),
                    Set            = reader.Current[5].ToString(),
                    Reps           = (Int64)reader.Current[6],
                    Value          = double.Parse(reader.Current[7].ToString()),
                    Unit           = reader.Current[8]?.ToString(),
                    DropSet        = (bool)reader.Current[9],
                    Note           = reader.Current[10]?.ToString()
                });
            }
            return(exerciseSession);
        }
Ejemplo n.º 4
0
        public async Task <int> CreateIndexAsync(NewIndex newIndex)
        {
            string query = $"CREATE INDEX ON :{newIndex.Label}({newIndex.Property})";
            int    count = 0;

            using (ISession session = this._driver.Session())
            {
                try
                {
                    await session.ReadTransactionAsync(async (tx) =>
                    {
                        IStatementResultCursor reader = await tx.RunAsync(query);
                        await reader.ConsumeAsync();
                        IResultSummary summary = await reader.SummaryAsync();
                        count = summary.Counters.IndexesAdded;
                    });
                }
                catch (Exception e)
                {
                    this._logger.LogError(e, $"Error creating index for label {newIndex.Label} on property {newIndex.Property}");
                }
                finally
                {
                    await session.CloseAsync();
                }
            }
            return(count);
        }
Ejemplo n.º 5
0
        public async Task <ResultSet> GetResultSetFromQueryAsync(string query, object props)
        {
            ResultSet returnedresults = new ResultSet();

            using (ISession session = this._driver.Session())
            {
                try
                {
                    await session.ReadTransactionAsync(async (tx) =>
                    {
                        IStatementResultCursor reader = await tx.RunAsync(query, props);
                        while (await reader.FetchAsync())
                        {
                            // Each current read in buffer can be reached via Current
                            returnedresults.Append(ParseRecord(reader.Current));
                        }
                    });
                }
                catch (Exception e)
                {
                    this._logger.LogError("Error running query from {0}: {1}", e.StackTrace, e.Message);
                    this._logger.LogError("Query {0}", query);
                }
                finally
                {
                    await session.CloseAsync();
                }
            }

            return(returnedresults);
        }
Ejemplo n.º 6
0
        public async Task <ResultSet> AdvancedSearch(AdvancedSearch.Search search)
        {
            string    query           = search.ToTokenizedSearchString();
            ResultSet returnedresults = new ResultSet();

            //validate the types/labels
            using (ISession session = this._driver.Session())
            {
                try
                {
                    await session.ReadTransactionAsync(async (tx) =>
                    {
                        IStatementResultCursor reader = await tx.RunAsync(query, search.Tokens.Properties);
                        while (await reader.FetchAsync())
                        {
                            returnedresults.Append(ParseRecord(reader.Current));
                        }
                    });
                }
                catch (Exception e)
                {
                    this._logger.LogError("Error running advanced search: " + e.Message);
                }
                finally
                {
                    await session.CloseAsync();
                }
            }

            return(returnedresults);
        }
Ejemplo n.º 7
0
 public static IEnumerable <T> MapTo <T>(this IStatementResultCursor record)
 {
     while (record.FetchAsync().Result)
     {
         yield return(record.Current.MapTo <T>());
     }
 }
        /// <summary>
        /// Return the only record in the result stream.
        /// </summary>
        /// <param name="result">The result stream</param>
        /// <typeparam name="TResult">The type of the returning value.</typeparam>
        /// <returns>The single element of the input sequence, or default(<paramref name="TResult">TResult</paramref> if the sequence contains no elements.</returns>
        /// <exception cref="T:System.ArgumentNullException"><paramref name="result">result</paramref> is null.</exception>
        /// <exception cref="T:System.ArgumentNullException"><paramref name="operation">operation</paramref> is null.</exception>
        /// <exception cref="T:System.InvalidOperationException">The input sequence contains more than one element.</exception>
        public static async Task <TResult> SingleOrDefaultAsync <TResult>(this IStatementResultCursor result, Func <IRecord, TResult> operation)
        {
            if (result == null)
            {
                throw new ArgumentNullException(nameof(result));
            }

            if (operation == null)
            {
                throw new ArgumentNullException(nameof(operation));
            }

            if (!await result.FetchAsync().ConfigureAwait(false))
            {
                return(default(TResult));
            }

            var record = result.Current;

            if (!await result.FetchAsync().ConfigureAwait(false))
            {
                return(operation(record));
            }

            throw new InvalidOperationException("The result contains more than one element.");
        }
Ejemplo n.º 9
0
            public async Task <int> AddEmployeesAsync(string companyName)
            {
                var session = Driver.Session();

                try
                {
                    var persons = await session.ReadTransactionAsync(async tx =>
                    {
                        IStatementResultCursor result = await tx.RunAsync("MATCH (a:Person) RETURN a.name AS name");
                        return(await result.ToListAsync());
                    });

                    return(persons.Sum(person => session.WriteTransactionAsync(async tx =>
                    {
                        await tx.RunAsync("MATCH (emp:Person {name: $person_name}) " +
                                          "MERGE (com:Company {name: $company_name}) " +
                                          "MERGE (emp)-[:WORKS_FOR]->(com)",
                                          new { person_name = person["name"].As <string>(), company_name = companyName });

                        return 1;
                    }).Result));
                }
                finally
                {
                    await session.CloseAsync();
                }
            }
Ejemplo n.º 10
0
 public async Task ProcessDelegatePerRecordFromQueryAsync(string query, object props, ProcessIRecord processor)
 {
     using (ISession session = this._driver.Session())
     {
         try
         {
             await session.ReadTransactionAsync(async (tx) =>
             {
                 IStatementResultCursor reader = await tx.RunAsync(query, props);
                 while (await reader.FetchAsync())
                 {
                     // Each current read in buffer can be reached via Current
                     processor(reader.Current);
                 }
             });
         }
         catch (Exception e)
         {
             this._logger.LogError("Error running query from {0}: {1}", e.StackTrace, e.Message);
             this._logger.LogError("Query {0}", query);
         }
         finally
         {
             await session.CloseAsync();
         }
     }
 }
        public InternalStatementResult(IStatementResultCursor cursor, BlockingExecutor executor)
        {
            _cursor   = cursor ?? throw new ArgumentNullException(nameof(cursor));
            _executor = executor ?? throw new ArgumentNullException(nameof(executor));

            _cursor    = cursor;
            _recordSet = new RecordSet(cursor, executor);
            _executor  = executor;
        }
Ejemplo n.º 12
0
        public static async Task <List <T> > MapToList <T>(this IStatementResultCursor record)
        {
            var result = new List <T>();

            while (await record.FetchAsync())
            {
                result.Add(record.Current.MapTo <T>());
            }
            return(result);
        }
Ejemplo n.º 13
0
 /// <summary>
 /// Read each record in the result stream and apply the operation on each record.
 /// </summary>
 /// <param name="result">The result stream.</param>
 /// <param name="operation">The operation is carried out on each record.</param>
 /// <returns>The result summary after all records have been processed.</returns>
 public static async Task <IResultSummary> ForEachAsync(this IStatementResultCursor result, Action <IRecord> operation)
 {
     Throw.ArgumentNullException.IfNull(result, nameof(result));
     while (await result.FetchAsync().ConfigureAwait(false))
     {
         var record = result.Current;
         operation(record);
     }
     return(await result.SummaryAsync().ConfigureAwait(false));
 }
Ejemplo n.º 14
0
        /// <summary>
        /// Pull all records in the result stream into memory and return in a list.
        /// </summary>
        /// <param name="result"> The result stream.</param>
        /// <returns>A list with all records in the result stream.</returns>
        public static async Task <List <IRecord> > ToListAsync(this IStatementResultCursor result)
        {
            Throw.ArgumentNullException.IfNull(result, nameof(result));
            List <IRecord> list = new List <IRecord>();

            while (await result.FetchAsync().ConfigureAwait(false))
            {
                list.Add(result.Current);
            }
            return(list);
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Apply the operation on each record in the result stream and return the operation results in a list.
        /// </summary>
        /// <typeparam name="T">The return type of the list</typeparam>
        /// <param name="result">The result stream.</param>
        /// <param name="operation">The operation to carry out on each record.</param>
        /// <returns>A list of collected operation result.</returns>
        public static async Task <List <T> > ToListAsync <T>(this IStatementResultCursor result, Func <IRecord, T> operation)
        {
            Throw.ArgumentNullException.IfNull(result, nameof(result));
            var list = new List <T>();

            while (await result.FetchAsync().ConfigureAwait(false))
            {
                var record = result.Current;
                list.Add(operation(record));
            }
            return(list);
        }
Ejemplo n.º 16
0
        public async Task <IEnumerable <string> > SearchEdgePropertyValuesAsync(string type, string property, string searchterm)
        {
            if (string.IsNullOrWhiteSpace(type))
            {
                throw new ArgumentException("Type is required");
            }
            if (string.IsNullOrWhiteSpace(property))
            {
                throw new ArgumentException("Property is required");
            }
            if (this._pluginmanager.EdgeDataTypes.Keys.Contains(type) == false)
            {
                throw new ArgumentException("Type not valid: " + type);
            }

            if (string.IsNullOrEmpty(type) || string.IsNullOrEmpty(property) || string.IsNullOrEmpty(searchterm))
            {
                return(new List <string>());
            }

            string regexterm = "(?i).*" + searchterm + ".*";


            List <string> results = new List <string>();

            using (ISession session = this._driver.Session())
            {
                try
                {
                    string query = "MATCH ()-[r:" + type + "]->() WHERE r[{prop}] =~ $regex RETURN DISTINCT r[{prop}] ORDER BY r[{prop}] LIMIT 20";

                    await session.ReadTransactionAsync(async (tx) =>
                    {
                        IStatementResultCursor reader = await tx.RunAsync(query, new { prop = property, regex = regexterm });
                        while (await reader.FetchAsync())
                        {
                            results.AddRange(ParseStringListRecord(reader.Current));
                        }
                    });
                }
                catch (Exception e)
                {
                    this._logger.LogError("Error querying SearchNodePropertyValues: " + e.Message);
                }
                finally
                {
                    await session.CloseAsync();
                }
            }

            return(results);
        }
Ejemplo n.º 17
0
        private async Task <Exercise> GetExercise(IStatementResultCursor reader)
        {
            Exercise item = null;

            while (await reader.FetchAsync())
            {
                item = new Exercise()
                {
                    Id   = Guid.Parse(reader.Current[0].ToString()),
                    Name = reader.Current[1].ToString(),
                    Note = reader.Current[2]?.ToString()
                };
            }
            return(item);
        }
Ejemplo n.º 18
0
        private async Task <User> GetUser(IStatementResultCursor reader)
        {
            User item = null;

            while (await reader.FetchAsync())
            {
                item = new User()
                {
                    Id      = Guid.Parse(reader.Current[0].ToString()),
                    Email   = reader.Current[1].ToString(),
                    Blocked = (bool?)reader.Current[2] ?? false
                };
            }
            return(item);
        }
Ejemplo n.º 19
0
        private async Task <Category> GetCategory(IStatementResultCursor reader)
        {
            Category item = null;

            while (await reader.FetchAsync())
            {
                item = new Category()
                {
                    Id   = Guid.Parse(reader.Current[0].ToString()),
                    Name = reader.Current[1].ToString(),
                    Note = reader.Current[2]?.ToString()
                };
            }
            return(item);
        }
        internal async Task <List <Person> > Find()
        {
            IDriver       driver = GraphDatabase.Driver("bolt://127.0.0.1:7687", AuthTokens.None);
            List <Person> nodes  = new List <Person>();

            using (ISession session = driver.Session(AccessMode.Read))
            {
                IStatementResultCursor result = await session.RunAsync("MATCH (n:Person) return n");

                await result.ForEachAsync(r =>
                {
                    nodes.Add(r[r.Keys[0]].Map <Person>());
                });
            }
            return(nodes);
        }
Ejemplo n.º 21
0
        private async Task <WorkoutSession> GetWorkoutSession(IStatementResultCursor reader)
        {
            WorkoutSession item = null;

            while (await reader.FetchAsync())
            {
                item = new WorkoutSession()
                {
                    Id   = Guid.Parse(reader.Current[0].ToString()),
                    Note = reader.Current[1]?.ToString(),
                    StartEpochTimestamp = double.Parse(reader.Current[2].ToString()),
                    EndEpochTimestamp   = (reader.Current[3] != null) ?
                                          double.Parse(reader.Current[3].ToString()) : 0
                };
            }
            return(item);
        }
Ejemplo n.º 22
0
        public async Task <IEnumerable <string> > SearchNodePropertyValuesAsync(string type, string property, string searchterm)
        {
            if (string.IsNullOrEmpty(property) || string.IsNullOrEmpty(searchterm))
            {
                return(new List <string>());
            }

            //replace the slashes so it picks up fs paths
            string regexterm = "(?i).*" + Regex.Escape(searchterm) + ".*";
            string typequery = string.Empty;

            if (string.IsNullOrWhiteSpace(type) == false)
            {
                typequery = "$type IN labels(n) AND ";
            }


            List <string> results = new List <string>();

            using (ISession session = this._driver.Session())
            {
                try
                {
                    string query = "MATCH (n) WHERE " + typequery + "n[{prop}]  =~ $regex RETURN DISTINCT n[{prop}] ORDER BY n[{prop}] LIMIT 20";

                    await session.ReadTransactionAsync(async (tx) =>
                    {
                        IStatementResultCursor reader = await tx.RunAsync(query, new { type, prop = property, regex = regexterm });
                        while (await reader.FetchAsync())
                        {
                            results.AddRange(ParseStringListRecord(reader.Current));
                        }
                    });
                }
                catch (Exception e)
                {
                    this._logger.LogError("Error querying SearchNodePropertyValues: " + e.Message);
                }
                finally
                {
                    await session.CloseAsync();
                }
            }

            return(results);
        }
Ejemplo n.º 23
0
        protected async Task <int> CountPersonAsync(string name)
        {
            var session = Driver.Session();

            try
            {
                return(await session.ReadTransactionAsync(async tx =>
                {
                    IStatementResultCursor result =
                        await tx.RunAsync("MATCH (a:Person {name: $name}) RETURN count(a)", new { name });

                    return (await result.SingleAsync())[0].As <int>();
                }));
            }
            finally
            {
                await session.CloseAsync();
            }
        }
Ejemplo n.º 24
0
        public async Task <string> Read()
        {
            string result = string.Empty;

            using (ISession session = GlobalDatabaseContext.Driver.Session())
            {
                string query = "match (user:User {name:\"User\"}) return user.name as Name";
                await session.ReadTransactionAsync(async x =>
                {
                    IStatementResultCursor cursor = await x.RunAsync(query);
                    var tmp = await cursor.ToListAsync(c => {
                        return(c.To <string>("Name"));
                    });
                    result = tmp.FirstOrDefault();
                    query  = string.Empty;
                });

                return(result);
            }
        }
        private async Task DiscardUnconsumedAsync()
        {
            if (_result != null)
            {
                IStatementResultCursor cursor = null;
                try
                {
                    cursor = await _result.ConfigureAwait(false);
                }
                catch (Exception)
                {
                    // ignored if the cursor failed to create
                }

                if (cursor != null)
                {
                    await cursor.SummaryAsync().ConfigureAwait(false);
                }
            }
        }
Ejemplo n.º 26
0
 /// <summary>
 /// Return the only record in the result stream.
 /// </summary>
 /// <param name="result">The result stream</param>
 /// <returns>The only record in the result stream.</returns>
 /// <remarks>Throws <exception cref="InvalidOperationException"></exception>
 /// if the result contains more than one record or the result is empty.</remarks>
 public static async Task <IRecord> SingleAsync(this IStatementResultCursor result)
 {
     Throw.ArgumentNullException.IfNull(result, nameof(result));
     if (await result.FetchAsync().ConfigureAwait(false))
     {
         var record = result.Current;
         if (!await result.FetchAsync().ConfigureAwait(false))
         {
             return(record);
         }
         else
         {
             throw new InvalidOperationException("The result contains more than one element.");
         }
     }
     else
     {
         throw new InvalidOperationException("The result is empty.");
     }
 }
        private async Task DiscardUnconsumed()
        {
            foreach (var result in _results)
            {
                IStatementResultCursor cursor = null;
                try
                {
                    cursor = await result.ConfigureAwait(false);
                }
                catch (Exception)
                {
                    // ignore if cursor failed to create
                }

                if (cursor != null)
                {
                    await cursor.SummaryAsync().ConfigureAwait(false);
                }
            }
        }
Ejemplo n.º 28
0
        private async Task <ExerciseRecord> GetExerciseRecord(IStatementResultCursor reader)
        {
            ExerciseRecord item = null;

            while (await reader.FetchAsync())
            {
                item = new ExerciseRecord()
                {
                    Id             = Guid.Parse(reader.Current[0].ToString()),
                    EpochTimestamp = double.Parse(reader.Current[1].ToString()),
                    Set            = reader.Current[2].ToString(),
                    Reps           = (Int64)reader.Current[3],
                    Value          = double.Parse(reader.Current[4].ToString()),
                    Unit           = reader.Current[5]?.ToString(),
                    DropSet        = (bool)reader.Current[6],
                    Note           = reader.Current[7]?.ToString()
                };
            }
            return(item);
        }
        private static Task AssertGetExpectResults(IStatementResultCursor cursor, int numberExpected, List <object> exspectedRecordsValues = null)
        {
            int count = 0;
            var t     = Task.Factory.StartNew(async() =>
            {
                // ReSharper disable once LoopCanBeConvertedToQuery
                while (await cursor.FetchAsync())
                {
                    if (exspectedRecordsValues != null)
                    {
                        cursor.Current.Values.First().Value.Should().Be(exspectedRecordsValues[count]);
                    }

                    count++;
                }

                count.Should().Be(numberExpected);
            });

            return(t);
        }
Ejemplo n.º 30
0
            public async Task TestDriverLifecycleExample()
            {
                // Given
                var driver  = new DriverLifecycleExample(Uri, User, Password).Driver;
                var session = driver.Session();

                try
                {
                    // When & Then
                    IStatementResultCursor result = await session.RunAsync("RETURN 1");

                    bool read = await result.FetchAsync();

                    read.Should().BeTrue();

                    result.Current[0].As <int>().Should().Be(1);
                }
                finally
                {
                    await session.CloseAsync();
                }
            }