コード例 #1
0
        internal Expression Rewrite()
        {
            var keys       = Grouping.KeyProjection;
            var keyColumns = new ColumnProjector(TabularExpressionHelper.CanBeColumn).ProjectColumns(keys);
            var keyFilters = keyColumns.Columns.Select(c => Expression.Equal(c.Expression, c.Expression)).Aggregate((x, y) => Expression.And(x, y));

            var subQueryBase =
                new CalculateTableExpression(Grouping.SubQueryProjectionExpression.Type,
                                             Grouping.SubQueryProjectionExpression.Source, keyFilters);
            var  subQuery  = new SubQueryProjection(Grouping.SubQueryProjectionExpression.Type, new ProjectionExpression(subQueryBase, Grouping.SubQueryProjectionExpression.Projector));
            Type groupType =
                typeof(TabularGrouping <,>).MakeGenericType(new Type[]
                                                            { Grouping.KeyProjection.Type, Grouping.SubQueryProjectionExpression.Type });

            return(new ProjectionExpression(new SummarizeExpression(groupType, new List <ColumnDeclaration>().AsReadOnly(), Grouping.SubQueryProjectionExpression.Source), subQuery));
        }
コード例 #2
0
        /// <summary>
        /// Transform subordinate queries
        /// </summary>
        /// <param name="projectionExpression">subordinate query</param>
        /// <returns>converted projection</returns>
        protected override Expression VisitSubQuery(SubQueryProjection projectionExpression)
        {
            var exp                   = (DaxExpression) new SubQueryProjectionBuilder().Visit(projectionExpression.Projection.Source);
            var projection            = new ProjectionExpression(exp, projectionExpression.Projection.Projector);
            var q                     = new SubQueryProjection(projectionExpression.Type, projection);
            LambdaExpression subQuery = Expression.Lambda(q, _row);
            MethodInfo       mi;

            if (projectionExpression.Type.IsGenericType)
            {
                Type elementType = TypeSystem.GetElementType(projectionExpression.Type);

                mi = _executeSubQuery.MakeGenericMethod(elementType);
            }
            else
            {
                mi = _executeSubQuery.MakeGenericMethod(subQuery.Body.Type);
            }

            return(Expression.Convert(Expression.Call(_row, mi, Expression.Constant(subQuery)), projectionExpression.Type));

            //MethodInfo mireturn base.Visit(projectionExpression);
        }
コード例 #3
0
 /// <summary>
 /// Skip subordinate queries
 /// </summary>
 /// <param name="projectionExpression">sub query</param>
 /// <returns>the expression</returns>
 protected override Expression VisitSubQuery(SubQueryProjection projectionExpression)
 {
     Visit(projectionExpression.Projection);
     return(projectionExpression);
 }