public void Test_FdbQueryUnionExpression()
        {
            var expr1 = FdbQueryIndexLookupExpression <int, string> .Lookup(
                FooBarIndex,
                (x) => x == "world"
                );

            var expr2 = FdbQueryIndexLookupExpression <int, long> .Lookup(
                FooBazIndex,
                (x) => x == 1234L
                );

            var expr = FdbQueryExpressions.Union(
                expr1,
                expr2
                );

            Log(expr);

            Assert.That(expr, Is.Not.Null);
            Assert.That(expr.Terms, Is.Not.Null);
            Assert.That(expr.Terms.Count, Is.EqualTo(2));
            Assert.That(expr.Terms[0], Is.SameAs(expr1));
            Assert.That(expr.Terms[1], Is.SameAs(expr2));

            Assert.That(expr.Type, Is.EqualTo(typeof(IAsyncEnumerable <int>)));
            Assert.That(expr.ElementType, Is.EqualTo(typeof(int)));

            Log(FdbQueryExpressions.ExplainSequence(expr));
        }
Esempio n. 2
0
        /// <summary>Return all the keys that share a common prefix</summary>
        /// <param name="query">Source database query</param>
        /// <param name="prefix">Shared prefix</param>
        /// <returns>Query that will return the keys that share the specified <paramref name="prefix"/></returns>
        public static IFdbAsyncSequenceQueryable <KeyValuePair <Slice, Slice> > RangeStartsWith(this IFdbDatabaseQueryable query, Slice prefix)
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }

            var expr = FdbQueryExpressions.RangeStartsWith(prefix);

            return(query.Provider.CreateSequenceQuery(expr));
        }
Esempio n. 3
0
        /// <summary>Return a range of keys</summary>
        /// <param name="query">Source database query</param>
        /// <param name="range">Pair of key selectors</param>
        /// <returns>Query that will return the keys from the specified <paramref name="range"/></returns>
        public static IFdbAsyncSequenceQueryable <KeyValuePair <Slice, Slice> > Range(this IFdbTransactionQueryable query, KeySelectorPair range)
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }

            var expr = FdbQueryExpressions.Range(range);

            return(query.Provider.CreateSequenceQuery(expr));
        }
Esempio n. 4
0
        /// <summary>Returns the first element of a sequence query</summary>
        public static Task <int> CountAsync <T>(this IFdbAsyncSequenceQueryable <T> query, CancellationToken ct = default(CancellationToken))
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }

            var expr = FdbQueryExpressions.Single <T, int>(
                (FdbQuerySequenceExpression <T>)query.Expression,
                "CountAsync",
                (source, _ct) => source.CountAsync(_ct)
                );

            return(query.Provider.CreateQuery <int>(expr).ExecuteSingle(ct));
        }
        public void Test_FdbQueryRangeExpression()
        {
            var expr = FdbQueryExpressions.Range(
                KeySelectorPair.Create(TuPack.ToKeyRange("Foo"))
                );

            Log(expr);

            Assert.That(expr, Is.Not.Null);
            Assert.That(expr.Range.Begin.Key.ToString(), Is.EqualTo("<02>Foo<00><00>"));
            Assert.That(expr.Range.End.Key.ToString(), Is.EqualTo("<02>Foo<00><FF>"));

            Assert.That(expr.Type, Is.EqualTo(typeof(IAsyncEnumerable <KeyValuePair <Slice, Slice> >)));
            Assert.That(expr.ElementType, Is.EqualTo(typeof(KeyValuePair <Slice, Slice>)));

            Log(FdbQueryExpressions.ExplainSequence(expr));
        }
Esempio n. 6
0
        public void Test_FdbQueryRangeExpression()
        {
            var expr = FdbQueryExpressions.Range(
                FdbTuple.Create("Foo").ToSelectorPair()
                );

            Console.WriteLine(expr);

            Assert.That(expr, Is.Not.Null);
            Assert.That(expr.Range.Begin.Key.ToString(), Is.EqualTo("<02>Foo<00>"));
            Assert.That(expr.Range.End.Key.ToString(), Is.EqualTo("<02>Foo<01>"));

            Assert.That(expr.Type, Is.EqualTo(typeof(IFdbAsyncEnumerable <KeyValuePair <Slice, Slice> >)));
            Assert.That(expr.ElementType, Is.EqualTo(typeof(KeyValuePair <Slice, Slice>)));

            Console.WriteLine(FdbQueryExpressions.ExplainSequence(expr));
        }
        public void Test_FdbQueryFilterExpression()
        {
            var expr = FdbQueryExpressions.Filter(
                FdbQueryExpressions.RangeStartsWith(TuPack.EncodeKey("Hello", "World")),
                (kvp) => kvp.Value.ToInt32() % 2 == 0
                );

            Log(expr);

            Assert.That(expr, Is.Not.Null);
            Assert.That(expr.Source, Is.Not.Null.And.InstanceOf <FdbQueryRangeExpression>());
            Assert.That(expr.Filter, Is.Not.Null);

            Assert.That(expr.Type, Is.EqualTo(typeof(IAsyncEnumerable <KeyValuePair <Slice, Slice> >)));
            Assert.That(expr.ElementType, Is.EqualTo(typeof(KeyValuePair <Slice, Slice>)));

            Log(FdbQueryExpressions.ExplainSequence(expr));
        }
        public void Test_FdbQueryTransformExpression()
        {
            var expr = FdbQueryExpressions.Transform(
                FdbQueryExpressions.RangeStartsWith(TuPack.EncodeKey("Hello", "World")),
                (kvp) => kvp.Value.ToUnicode()
                );

            Log(expr);

            Assert.That(expr, Is.Not.Null);
            Assert.That(expr.Source, Is.Not.Null.And.InstanceOf <FdbQueryRangeExpression>());
            Assert.That(expr.Transform, Is.Not.Null);

            Assert.That(expr.Type, Is.EqualTo(typeof(IAsyncEnumerable <string>)));
            Assert.That(expr.ElementType, Is.EqualTo(typeof(string)));

            Log(FdbQueryExpressions.ExplainSequence(expr));
        }
Esempio n. 9
0
        /// <summary>Returns the first element of a sequence query</summary>
        public static Task <T> FirstOrDefaultAsync <T>(this IFdbAsyncSequenceQueryable <T> query, CancellationToken ct = default(CancellationToken))
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }
            if (ct.IsCancellationRequested)
            {
                return(Task.FromCanceled <T>(ct));
            }

            var expr = FdbQueryExpressions.Single <T, T>(
                (FdbQuerySequenceExpression <T>)query.Expression,
                "FirstOrDefaultAsync",
                (source, _ct) => source.FirstOrDefaultAsync(_ct)
                );

            return(query.Provider.CreateQuery <T>(expr).ExecuteSingle(ct));
        }
        public void Test_FdbQueryIndexLookupExpression_From_Lambda()
        {
            var expr = FdbQueryIndexLookupExpression <int, string> .Lookup(
                FooBarIndex,
                (bar) => bar == "world"
                );

            Log(expr);

            Assert.That(expr, Is.Not.Null);
            Assert.That(expr.Index, Is.SameAs(FooBarIndex));             //TODO: .Index.Index does not look very nice
            Assert.That(expr.Operator, Is.EqualTo(ExpressionType.Equal));
            Assert.That(expr.Value, Is.Not.Null);
            Assert.That(expr.Value, Is.InstanceOf <ConstantExpression>().With.Property("Value").EqualTo("world"));

            Assert.That(expr.Type, Is.EqualTo(typeof(IAsyncEnumerable <int>)));
            Assert.That(expr.ElementType, Is.EqualTo(typeof(int)));

            Log(FdbQueryExpressions.ExplainSequence(expr));
        }
Esempio n. 11
0
        /// <summary>Filters a sequence query of values based on a predicate.</summary>
        public static IFdbAsyncSequenceQueryable <T> Where <T>(this IFdbAsyncSequenceQueryable <T> query, Expression <Func <T, bool> > predicate)
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }
            if (predicate == null)
            {
                throw new ArgumentNullException(nameof(predicate));
            }

            var sourceExpr = query.Expression as FdbQuerySequenceExpression <T>;

            if (sourceExpr == null)
            {
                throw new ArgumentException("query");
            }

            var expr = FdbQueryExpressions.Filter(sourceExpr, predicate);

            return(query.Provider.CreateSequenceQuery <T>(expr));
        }
Esempio n. 12
0
        /// <summary>Projects each element of a sequence query into a new form.</summary>
        public static IFdbAsyncSequenceQueryable <R> Select <T, R>(this IFdbAsyncSequenceQueryable <T> query, Expression <Func <T, R> > selector)
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }
            if (selector == null)
            {
                throw new ArgumentNullException(nameof(selector));
            }

            var sourceExpr = query.Expression as FdbQuerySequenceExpression <T>;

            if (sourceExpr == null)
            {
                throw new ArgumentException("query");
            }

            var expr = FdbQueryExpressions.Transform(sourceExpr, selector);

            return(query.Provider.CreateSequenceQuery <R>(expr));
        }