public void HandleResultOperator ()
    {
      var resultOperator = new AnyResultOperator ();
      var sqlStatement = _sqlStatementBuilder.GetSqlStatement();

      var fakePreparedSelectProjection = Expression.Constant (false);

      _stageMock
         .Expect (mock => mock.PrepareSelectExpression (Arg<Expression>.Matches (e => e is SqlExistsExpression), Arg.Is (_context)))
         .WhenCalled (
             mi =>
             {
               var selectProjection = (Expression) mi.Arguments[0];
               Assert.That (selectProjection, Is.TypeOf (typeof (SqlExistsExpression)));

               var expectedExistsExpression = new SqlExistsExpression (new SqlSubStatementExpression (sqlStatement));
               SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExistsExpression, selectProjection);
             })
         .Return (fakePreparedSelectProjection);

      _handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);

      Assert.That (_sqlStatementBuilder.DataInfo, Is.TypeOf (typeof (StreamedScalarValueInfo)));
      Assert.That (((StreamedScalarValueInfo) _sqlStatementBuilder.DataInfo).DataType, Is.EqualTo (typeof (Boolean)));

      _stageMock.VerifyAllExpectations ();

      Assert.That (_sqlStatementBuilder.SelectProjection, Is.SameAs (fakePreparedSelectProjection));
    }
        public void HandleResultOperator()
        {
            var resultOperator = new AnyResultOperator();
            var sqlStatement   = _sqlStatementBuilder.GetSqlStatement();

            var fakePreparedSelectProjection = Expression.Constant(false);

            _stageMock
            .Expect(mock => mock.PrepareSelectExpression(Arg <Expression> .Matches(e => e is SqlExistsExpression), Arg.Is(_context)))
            .WhenCalled(
                mi =>
            {
                var selectProjection = (Expression)mi.Arguments[0];
                Assert.That(selectProjection, Is.TypeOf(typeof(SqlExistsExpression)));

                var expectedExistsExpression = new SqlExistsExpression(new SqlSubStatementExpression(sqlStatement));
                SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExistsExpression, selectProjection);
            })
            .Return(fakePreparedSelectProjection);

            _handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);

            Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedScalarValueInfo)));
            Assert.That(((StreamedScalarValueInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(Boolean)));

            _stageMock.VerifyAllExpectations();

            Assert.That(_sqlStatementBuilder.SelectProjection, Is.SameAs(fakePreparedSelectProjection));
        }
        private void VisitAnyResultOperator(AnyResultOperator anyResultOperator, Remotion.Linq.QueryModel queryModel, int index)
        {
            string targetIdentifierString            = _visitor.Query.CreateIdentifier(_visitor.ItemNameOverride);
            IList <EntityConstrain> entityConstrains = null;
            StrongEntityAccessor    entityAccessor   = (from accessor in _visitor.Query.GetQueryComponentNavigator().FindAllComponents <StrongEntityAccessor>()
                                                        let constrains = accessor.Elements.OfType <EntityConstrain>()
                                                                         from constrain in constrains
                                                                         let predicate = constrain.Predicate as Literal
                                                                                         where predicate != null
                                                                                         let predicateUri = (Uri)predicate.Value
                                                                                                            let identifier = constrain.Value as Identifier
                                                                                                                             where identifier != null
                                                                                                                             let identifierString = _visitor.Query.RetrieveIdentifier(identifier.Name)
                                                                                                                                                    where (identifierString == targetIdentifierString) || ((_fromExpression != null) && (constrain.TargetExpression.EqualsTo(_fromExpression)))
                                                                                                                                                    where (entityConstrains = constrains.Where(item =>
                                                                                                                                                                                               (item.Predicate is Literal) && (((Uri)((Literal)item.Predicate).Value).AbsoluteUri == predicateUri.AbsoluteUri)).ToList()).Count > 0
                                                                                                                                                    select accessor).FirstOrDefault();

            if (entityAccessor != null)
            {
                foreach (EntityConstrain entityConstrain in entityConstrains)
                {
                    int indexOf = entityAccessor.Elements.IndexOf(entityConstrain);
                    entityAccessor.Elements.RemoveAt(indexOf);
                    OptionalPattern optional = new OptionalPattern();
                    optional.Patterns.Add(entityConstrain);
                    entityAccessor.Elements.Insert(indexOf, optional);
                }
            }

            Call call = new Call(MethodNames.Bound);

            _result = call;
        }
 private void VisitAnyResultOperator(AnyResultOperator anyResultOperator, Remotion.Linq.QueryModel queryModel, int index)
 {
     if (_query.IsSubQuery)
     {
         Call call = new Call(MethodNames.Any);
         call.Arguments.Add(_query);
         _result = call;
     }
     else
     {
         _query.QueryForm = QueryForms.Ask;
     }
 }
 private static Expression ProcessResultOperator(Expression expression, Type expressionItemType, AnyResultOperator _)
 {
     return(Expression.Call(_anyAsyncShim.MakeGenericMethod(expressionItemType), expression));
 }
예제 #6
0
 private static Expression HandleResultOperator(Expression expression, Type expressionItemType, AnyResultOperator _)
 {
     return(Expression.Call(_any.MakeGenericMethod(expressionItemType), expression));
 }
예제 #7
0
 public void SetUp()
 {
     _resultOperator = new AnyResultOperator();
 }
 private bool TryHandleAny(SubQueryExpression subquery, AnyResultOperator ro) => TryHandleAllAny(subquery, (subquery.QueryModel.BodyClauses.FirstOrDefault() as WhereClause)?.Predicate, "ANY");
        private void VisitAnyResultOperator(AnyResultOperator anyResultOperator, Remotion.Linq.QueryModel queryModel, int index)
        {
            string targetIdentifierString = _visitor.Query.CreateIdentifier(_visitor.ItemNameOverride);
            IList<EntityConstrain> entityConstrains = null;
            StrongEntityAccessor entityAccessor = (from accessor in _visitor.Query.GetQueryComponentNavigator().FindAllComponents<StrongEntityAccessor>()
                                                   let constrains = accessor.Elements.OfType<EntityConstrain>()
                                                   from constrain in constrains
                                                   let predicate = constrain.Predicate as Literal
                                                   where predicate != null
                                                   let predicateUri = (Uri)predicate.Value
                                                   let identifier = constrain.Value as Identifier
                                                   where identifier != null
                                                   let identifierString = _visitor.Query.RetrieveIdentifier(identifier.Name)
                                                   where identifierString == targetIdentifierString
                                                   where (entityConstrains = constrains.Where(item =>
                                                       (item.Predicate is Literal) && (((Uri)((Literal)item.Predicate).Value).AbsoluteUri == predicateUri.AbsoluteUri)).ToList()).Count > 0
                                                   select accessor).FirstOrDefault();
            if (entityAccessor != null)
            {
                foreach (EntityConstrain entityConstrain in entityConstrains)
                {
                    int indexOf = entityAccessor.Elements.IndexOf(entityConstrain);
                    entityAccessor.Elements.RemoveAt(indexOf);
                    OptionalPattern optional = new OptionalPattern();
                    optional.Patterns.Add(entityConstrain);
                    entityAccessor.Elements.Insert(indexOf, optional);
                }
            }

            Call call = new Call(MethodNames.Bound);
            _result = call;
        }
 private void VisitAnyResultOperator(AnyResultOperator anyResultOperator, Remotion.Linq.QueryModel queryModel, int index)
 {
     if (_query.IsSubQuery)
     {
         Call call = new Call(MethodNames.Any);
         call.Arguments.Add(_query);
         _result = call;
     }
     else
     {
         _query.QueryForm = QueryForms.Ask;
     }
 }
예제 #11
0
 public void SetUp ()
 {
   _resultOperator = new AnyResultOperator ();
 }