public override void ProcessMethodCall(IOqlSyntaxContext callContext, MethodCallExpression methodCall)
        {
            if (methodCall.IsCalled(Skip))
            {
                callContext.CallResult.Offset = (int)methodCall.GetArgument(1).GetValue();
                return;
            }

            if (methodCall.IsCalled(Take))
            {
                callContext.CallResult.Size = (int)methodCall.GetArgument(1).GetValue();
                return;
            }

            if (methodCall.IsCalled(ElementAt))
            {
                callContext.CallResult.Command      = OqlCommandToken.ElementAt;
                callContext.CallResult.ElementIndex = (int)methodCall.GetArgument(1).GetValue();
                return;
            }

            if (methodCall.IsCalled(ElementAtOrDefault))
            {
                callContext.CallResult.ElementIndex = (int)methodCall.GetArgument(1).GetValue();
                callContext.CallResult.Command      = OqlCommandToken.ElementAt | OqlCommandToken.DefaultFlag;
                return;
            }

            ProcessNavigate(callContext, methodCall);
        }
        public override void ProcessMethodCall(IOqlSyntaxContext callContext, MethodCallExpression methodCall)
        {
            if (methodCall.IsCalled(OuterJoin))
            {
            }

            if (methodCall.IsCalled(InnerJoin))
            {
            }
        }
        public static void ProcessNavigate(IOqlSyntaxContext callContext, MethodCallExpression methodCall)
        {
            callContext.CallResult.ResultType = methodCall.Type;

            if (methodCall.IsCalledOr(AnyWithPredicate, AnyWithoutPredicate))
            {
                callContext.CallResult.Command = OqlCommandToken.IsAny;
                return;
            }


            if (methodCall.IsCalledOr(FirstWithPredicate, FirstWithoutPredicate))
            {
                callContext.CallResult.Command = OqlCommandToken.First;
                return;
            }

            if (methodCall.IsCalledOr(FirstOrDefaultWithPredicate, FirstOrDefaultWithoutPredicate))
            {
                callContext.CallResult.Command = OqlCommandToken.First | OqlCommandToken.DefaultFlag;
                return;
            }

            if (methodCall.IsCalledOr(SingleWithPredicate, SingleWithoutPredicate))
            {
                callContext.CallResult.Command = OqlCommandToken.Single;
                return;
            }

            if (methodCall.IsCalledOr(SingleOrDefaultWithPredicate, SingleOrDefaultWithoutPredicate))
            {
                callContext.CallResult.Command = OqlCommandToken.Single | OqlCommandToken.DefaultFlag;
                return;
            }

            if (methodCall.IsCalledOr(LastWithPredicate, LastWithoutPredicate))
            {
                callContext.CallResult.Command = OqlCommandToken.Last;
                return;
            }

            if (methodCall.IsCalledOr(LastOrDefaultWithPredicate, LastOrDefaultWithoutPredicate))
            {
                callContext.CallResult.Command = OqlCommandToken.Last | OqlCommandToken.DefaultFlag;
                return;
            }

            if (methodCall.IsCalledOr(CountWithPredicate, LongCountWithPredicate))
            {
                callContext.CallResult.Command = OqlCommandToken.Scalar;
                return;
            }
        }
        public override void ProcessMethodCall(IOqlSyntaxContext callContext, MethodCallExpression methodCall)
        {
            if (methodCall.IsCalled(SkipWhile))
            {
                AndAlso(Expression.Not(methodCall.GetArgument(1)));
                return;
            }

            AndAlso(methodCall.GetArgument(1));

            OqlNavigationClause.ProcessNavigate(callContext, methodCall);
        }
Example #5
0
        public override void ProcessMethodCall(IOqlSyntaxContext callContext, MethodCallExpression methodCall)
        {
            if (Distinct.Equals(methodCall))
            {
                m_has_distinct = true;
                return;
            }


            m_select_expression = methodCall.GetArgument(1);


            callContext.CallResult.ResultType = methodCall.Type;


            if (m_select_expression.NodeType == ExpressionType.MemberInit || m_select_expression.NodeType == ExpressionType.New)
            {
                return;
            }

            if (methodCall.IsCalled(Min))
            {
                visit_to_aggregate = (x, y) => callContext.AggregateFormatter.FormatMin(x, y);
                return;
            }

            if (methodCall.IsCalled(Max))
            {
                visit_to_aggregate = (x, y) => callContext.AggregateFormatter.FormatMax(x, y);
                return;
            }


            if (methodCall.IsCalled("Average"))
            {
                visit_to_aggregate = (x, y) => callContext.AggregateFormatter.FormatAverage(x, y);
                return;
            }

            if (methodCall.IsCalled("Sum"))
            {
                visit_to_aggregate = (x, y) => callContext.AggregateFormatter.FormatSum(x, y);
                return;
            }


            if (methodCall.IsCalledOr(Count, LongCount))
            {
                callContext.CallResult.Command = OqlCommandToken.Scalar;
            }

            visit_to_aggregate = null;
        }
Example #6
0
        public override void ProcessMethodCall(IOqlSyntaxContext callContext, MethodCallExpression methodCall)
        {
            Expression x = methodCall.GetArgument(1);

            if (x.NodeType == ExpressionType.MemberInit)
            {
                m_change_set = new MemberInitChangeSet(x as MemberInitExpression);
                return;
            }

            object obj = x.GetValue();

            if (obj is IDataChangeSet)
            {
                m_change_set = obj as IDataChangeSet;
                return;
            }


            m_change_set = new ObjectChangeSet(obj).ChangeAllProperties();
        }
Example #7
0
 public override void ProcessMethodCall(IOqlSyntaxContext callContext, MethodCallExpression methodCall)
 {
     m_order_stack.Push(methodCall);
 }
 public OqlExpressionVisitor(IOqlSyntaxContext provider)
 {
     m_syntax_context = provider;
     m_query_builder  = provider.CreateQueryBuilder();
 }
Example #9
0
 public abstract void ProcessMethodCall(IOqlSyntaxContext callContext, MethodCallExpression methodCall);
Example #10
0
 public override void ProcessMethodCall(IOqlSyntaxContext callContext, MethodCallExpression methodCall)
 {
 }