public virtual VfpExpression Visit(VfpProjectExpression expression)
        {
            var projection = expression.Projection.Accept(this);
            var input      = VisitVfpExpressionBinding(expression.Input);

            return(new VfpProjectExpression(expression.ResultType, input, projection));
        }
Ejemplo n.º 2
0
        public override VfpExpression Visit(VfpProjectExpression expression)
        {
            Write(" SELECT ");

            expression.Projection.Accept(this);
            VisitVfpExpressionBinding(expression.Input);

            return(expression);
        }
        public override VfpExpression Visit(VfpProjectExpression expression)
        {
            VfpProjectExpression innerProjectionExpression;
            bool hasNotExpression;

            if (GetInnerProjectionExpression(expression, out innerProjectionExpression, out hasNotExpression))
            {
                var innerNewInstanceExpression = innerProjectionExpression.Projection as VfpNewInstanceExpression;

                if (innerNewInstanceExpression != null)
                {
                    var innerConstExpression = innerNewInstanceExpression.Arguments[0] as VfpConstantExpression;

                    if (innerConstExpression != null)
                    {
                        var countExpression = new VfpConstantExpression(innerConstExpression.ResultType, "COUNT(*)");
                        innerNewInstanceExpression = new VfpNewInstanceExpression(innerNewInstanceExpression.ResultType, new VfpExpressionList(new List <VfpExpression> {
                            countExpression
                        }));
                        innerProjectionExpression = new VfpProjectExpression(innerProjectionExpression.ResultType, innerProjectionExpression.Input, innerNewInstanceExpression);

                        VfpExpression comparison = new VfpComparisonExpression(VfpExpressionKind.LessThan,
                                                                               PrimitiveTypeKind.Boolean.ToTypeUsage(),
                                                                               new VfpConstantExpression(
                                                                                   PrimitiveTypeKind.Int32.ToTypeUsage(), 0),
                                                                               innerProjectionExpression);

                        if (!hasNotExpression)
                        {
                            comparison = new VfpNotExpression(comparison.ResultType, comparison);
                        }

                        innerNewInstanceExpression = new VfpNewInstanceExpression(innerNewInstanceExpression.ResultType, new VfpExpressionList(new List <VfpExpression> {
                            comparison
                        }));
                        innerProjectionExpression = new VfpProjectExpression(expression.ResultType, expression.Input, innerNewInstanceExpression);

                        return(innerProjectionExpression);
                    }
                }
            }

            return(base.Visit(expression));
        }
        private static bool GetInnerProjectionExpression(VfpProjectExpression expression, out VfpProjectExpression innerProjectionExpression, out bool hasNotExpression)
        {
            innerProjectionExpression = null;
            hasNotExpression          = false;

            if (!expression.Input.VariableName.StartsWith("SingleRowTable"))
            {
                return(false);
            }

            var newInstanceExpression = expression.Projection as VfpNewInstanceExpression;

            if (newInstanceExpression == null)
            {
                return(false);
            }

            var notExpression = newInstanceExpression.Arguments[0] as VfpNotExpression;
            VfpIsEmptyExpression isEmptyExpression = null;

            if (notExpression == null)
            {
                isEmptyExpression = newInstanceExpression.Arguments[0] as VfpIsEmptyExpression;
            }
            else
            {
                isEmptyExpression = notExpression.Argument as VfpIsEmptyExpression;
                hasNotExpression  = true;
            }

            if (isEmptyExpression == null)
            {
                return(false);
            }

            innerProjectionExpression = isEmptyExpression.Argument as VfpProjectExpression;

            return(innerProjectionExpression != null);
        }
        public override VfpExpression Visit(VfpProjectExpression expression)
        {
            var result = base.Visit(expression);

            expression = result as VfpProjectExpression;

            if (expression == null)
            {
                return(result);
            }

            var filterExpression = expression.Input.Expression as VfpFilterExpression;

            if (IsZeroEqualsZero(filterExpression))
            {
                var projectionExpression = GetProjection(filterExpression, expression.Input.VariableName, expression.Projection);

                return(filterExpression.Input.Project(projectionExpression));
            }

            return(result);
        }
        private static VfpLimitExpression GetVfpLimitExpression(VfpLimitExpression limitExpression, VfpProjectExpression projectExpression)
        {
            var keyMembers = GetKeyMembers(projectExpression);

            if (!keyMembers.Any())
            {
                return(null);
            }

            var sortBinding = GetSortBinding(keyMembers, projectExpression.Input, projectExpression);
            var newProject  = sortBinding.Project(projectExpression.Projection);

            return(new VfpLimitExpression(limitExpression.ResultType,
                                          newProject,
                                          limitExpression.Limit,
                                          limitExpression.WithTies));
        }
 private static IEnumerable <EdmMember> GetKeyMembers(VfpProjectExpression expression)
 {
     return(expression == null ? new EdmMember[] { } : GetKeyMembers(expression.Input, expression));
 }