示例#1
0
        public void Rewrite_NullableWithHasValueAndPropertyEquality_RewritesHasValue()
        {
            Expression <Func <LdapGroup, bool> > input = e => e.PhoneNumber.HasValue && e.PhoneNumber == 1234567890;
            // ReSharper disable once RedundantLogicalConditionalExpressionOperand
            Expression <Func <LdapGroup, bool> > expected = e => true && e.PhoneNumber == 1234567890;

            Expression rewritten = new BooleanRewriter().Visit(input);

            Assert.AreEqual(expected.ToString(), rewritten?.ToString());
        }
示例#2
0
        public void Rewrite_Conditional_RewritesCorrectly()
        {
            Expression <Func <LdapGroup, bool> > input = e =>
                                                         ("test".Equals("test")
                    ? e.DistinguishedName == "cn=fakegroup,dc=example,dc=com"
                    : e.PhoneNumber == 1234567890);
            Expression <Func <LdapGroup, bool> > expected = e => e.DistinguishedName == "cn=fakegroup,dc=example,dc=com";

            Expression rewritten = new BooleanRewriter().Visit(input);

            Assert.AreEqual(expected.ToString(), rewritten?.ToString());
        }
        public void Rewrite_NullableWithHasValueAndPropertyEquality_RewritesHasValue()
        {
            //prepare
            DateTime?now         = DateTime.Now;
            var      expression1 = _queryContext.Query <BooleanRewriterTest>().Where(e => now.HasValue && e.Property1 == now.Value).Expression;

            var expression2 = _queryContext.Query <BooleanRewriterTest>().Where(e => true && e.Property1 == now.Value).Expression;

            //act
            var rewritten = new BooleanRewriter().Rewrite(expression1);

            //assert
            expression2.ToString().Should().Be.EqualTo(rewritten.ToString());
        }
        public void Rewrite_HasValueAndMethodAndPropertyEquality_RewritesHasValueAndMethodToSingleTrue()
        {
            //prepare
            DateTime?now = DateTime.Now;

            _queryContext.Query <BooleanRewriterTest>().Where(e => now.HasValue && e.Property1 == now.Value && !"true".Equals("true"));
            var expression1 = _queryContext.ActiveProvider.CurrentExpression;

            _queryContext.Query <BooleanRewriterTest>().Where(e => true && e.Property1 == now.Value && false);
            var expression2 = _queryContext.ActiveProvider.CurrentExpression;

            var rewritten = new BooleanRewriter().Rewrite(expression1);

            expression2.ToString().Should().Be.EqualTo(rewritten.ToString());
        }
        public void Rewrite_NullableWithHasValueAndPropertyEqualityAndBoolCast_RewritesHasValue()
        {
            //prepare
            DateTime?now = DateTime.Now;

            _queryContext.Query <BooleanRewriterTest>().Where(e => (e.Property2 == "test") || (e.Property1 == now.Value && now.HasValue is bool && (bool)(now.HasValue as object) == true));
            var expression1 = _queryContext.ActiveProvider.CurrentExpression;

            _queryContext.Query <BooleanRewriterTest>().Where(e => e.Property2 == "test" || (e.Property1 == now.Value && true && true));
            var expression2 = _queryContext.ActiveProvider.CurrentExpression;

            //act
            var rewritten = new BooleanRewriter().Rewrite(expression1);

            //assert
            expression2.ToString().Should().Be.EqualTo(rewritten.ToString());
        }
        public void Rewrite_Conditional_RewritesCorrectly()
        {
            //prepare
            DateTime?now = DateTime.Now;

            _queryContext.Query <BooleanRewriterTest>().Where(e => "test".Equals("test") ? e.Property2 == "test" : e.Property1 == now.Value);
            var expression1 = _queryContext.ActiveProvider.CurrentExpression;

            _queryContext.Query <BooleanRewriterTest>().Where(e => e.Property2 == "test");
            var expression2 = _queryContext.ActiveProvider.CurrentExpression;

            //act
            var rewritten = new BooleanRewriter().Rewrite(expression1);

            //assert
            expression2.ToString().Should().Be.EqualTo(rewritten.ToString());
        }
        public void Rewrite_HasValueAndMethodWithParameterAndPropertyEquality_RewritesHasValueAndMethod()
        {
            //prepare
            DateTime?now  = DateTime.Now;
            var      list = new [] { "test" };

            _queryContext.Query <BooleanRewriterTest>().Where(e => list.Length > 0 && list.Contains(e.Property2) && now.HasValue && e.Property1 == now.Value);
            var expression1 = _queryContext.ActiveProvider.CurrentExpression;

            _queryContext.Query <BooleanRewriterTest>().Where(e => true && list.Contains(e.Property2) && true && e.Property1 == now.Value);
            var expression2 = _queryContext.ActiveProvider.CurrentExpression;

            //act
            var rewritten = new BooleanRewriter().Rewrite(expression1);

            //assert
            expression2.ToString().Should().Be.EqualTo(rewritten.ToString());
        }
示例#8
0
        public Expression <Func <TEntity, bool> > Compile <TEntity>(string query)
            where TEntity : class
        {
            if (!_configuration.Mappings.TryGetValue(typeof(TEntity), out var entityConfiguration))
            {
                throw new InvalidOperationException("Entity has not been configured.");
            }

            // Parse the expression.
            var expression = QueryExpressionParser.Parse(entityConfiguration, query);

            // expression = CollectionRewriter.Rewrite(expression);
            expression = BooleanRewriter.Rewrite(expression);
            expression = ConversionRewriter.Rewrite(expression);

            // Translate the expression.
            return(QueryTranslator <TContext, TEntity> .Translate(expression));
        }
        public static string ToSql(QueryConfiguration <TContext> configuration, string query)
        {
            var entityType = typeof(TEntity);

            if (!configuration.Mappings.TryGetValue(typeof(TEntity), out var entityConfiguration))
            {
                throw new InvalidOperationException("Entity has not been configured.");
            }

            // Parse the expression and rewrite it.
            var expression = ExpressionParser.Parse(query);

            expression = BooleanRewriter <TEntity> .Rewrite(expression);

            expression = NullRewriter <TEntity> .Rewrite(expression);

            // Generate the SQL statement.
            return(GenerateSqlStatement(entityConfiguration, expression));
        }
        public void Rewrite_HasValueAndCollectionContainsWithOrCondition_RewritesHasValue()
        {
            //prepare
            DateTime?now  = DateTime.Now;
            var      list = new List <string> {
                "test"
            };

            _queryContext.Query <BooleanRewriterTest>().Where(e => (list.Contains(e.Property2) && !e.Property3 && e.Property1 == now.Value) || now.HasValue);
            var expression1 = _queryContext.ActiveProvider.CurrentExpression;

            _queryContext.Query <BooleanRewriterTest>().Where(e => (list.Contains(e.Property2) && !e.Property3 && e.Property1 == now.Value) || true);
            var expression2 = _queryContext.ActiveProvider.CurrentExpression;

            //act
            var rewritten = new BooleanRewriter().Rewrite(expression1);

            //assert
            expression2.ToString().Should().Be.EqualTo(rewritten.ToString());
        }
示例#11
0
        public IQueryable <TEntity> Query <TEntity>(TContext context, string query)
            where TEntity : class
        {
            if (!_configuration.Mappings.TryGetValue(typeof(TEntity), out var entityConfiguration))
            {
                throw new InvalidOperationException("Entity has not been configured.");
            }

            // Parse the expression.
            var expression = QueryExpressionParser.Parse(entityConfiguration, query);

            expression = BooleanRewriter.Rewrite(expression);
            expression = NullableRewriter.Rewrite(expression);

            // Translate the expression.
            var result = QueryTranslator <TContext, TEntity> .Translate(expression);

            return(entityConfiguration.IsQueryType
                ? context.Query <TEntity>().Where(result)
                : context.Set <TEntity>().Where(result));
        }