Ejemplo n.º 1
0
        public virtual ProjectionExpression AddOuterJoinTest(ProjectionExpression proj)
        {
            var test   = this.GetOuterJoinTest(proj.Select);
            var select = proj.Select;
            ColumnExpression testCol = null;

            // look to see if test expression exists in columns already
            foreach (var col in select.Columns)
            {
                if (test.Equals(col.Expression))
                {
                    var colType = SqlType.Get(test.Type);
                    testCol = new ColumnExpression(test.Type, colType, select.Alias, col.Name);
                    break;
                }
            }
            if (testCol == null)
            {
                // add expression to projection
                testCol = test as ColumnExpression;
                string colName = (testCol != null) ? testCol.Name : "Test";
                colName = proj.Select.Columns.GetAvailableColumnName(colName);
                var colType = SqlType.Get(test.Type);
                select  = select.AddColumn(new ColumnDeclaration(colName, test, colType));
                testCol = new ColumnExpression(test.Type, colType, select.Alias, colName);
            }
            var newProjector = new OuterJoinedExpression(testCol, proj.Projector);

            return(new ProjectionExpression(select, newProjector, proj.Aggregator));
        }
Ejemplo n.º 2
0
 public virtual ProjectionExpression AddOuterJoinTest(ProjectionExpression proj)
 {
     var test = this.GetOuterJoinTest(proj.Select);
     var select = proj.Select;
     ColumnExpression testCol = null;
     // look to see if test expression exists in columns already
     foreach (var col in select.Columns)
     {
         if (test.Equals(col.Expression))
         {
             var colType = SqlType.Get(test.Type);
             testCol = new ColumnExpression(test.Type, colType, select.Alias, col.Name);
             break;
         }
     }
     if (testCol == null)
     {
         // add expression to projection
         testCol = test as ColumnExpression;
         string colName = (testCol != null) ? testCol.Name : "Test";
         colName = proj.Select.Columns.GetAvailableColumnName(colName);
         var colType = SqlType.Get(test.Type);
         select = select.AddColumn(new ColumnDeclaration(colName, test, colType));
         testCol = new ColumnExpression(test.Type, colType, select.Alias, colName);
     }
     var newProjector = new OuterJoinedExpression(testCol, proj.Projector);
     return new ProjectionExpression(select, newProjector, proj.Aggregator);
 }
Ejemplo n.º 3
0
        public static ProjectionExpression AddOuterJoinTest(this ProjectionExpression proj, QueryLanguage language, Expression expression)
        {
            string colName = proj.Select.Columns.GetAvailableColumnName("Test");
            //var colType = language.TypeSystem.GetColumnType(expression.Type);
            SelectExpression newSource    = proj.Select.AddColumn(new ColumnDeclaration(colName, expression));
            Expression       newProjector = new OuterJoinedExpression(new ColumnExpression(expression.Type, newSource.Alias, colName), proj.Projector);

            return(new ProjectionExpression(newSource, newProjector, proj.Aggregator));
        }
		public static ProjectionExpression AddOuterJoinTest(this ProjectionExpression proj, Expression expression)
		{
			string colName = proj.Select.Columns.GetAvailableColumnName("Test");
			var colType = DbTypeSystem.GetColumnType(expression.Type);
			SelectExpression newSource = proj.Select.AddColumn(new ColumnDeclaration(colName, expression, colType));
			Expression newProjector =
				new OuterJoinedExpression(new ColumnExpression(expression.Type, colType, newSource.Alias, colName), proj.Projector);
			return new ProjectionExpression(newSource, newProjector, proj.Aggregator);
		}
Ejemplo n.º 5
0
        protected override Expression VisitOuterJoined(OuterJoinedExpression outer)
        {
            var expr   = Visit(outer.Expression);
            var column = (ColumnExpression)outer.Test;

            if (_scope.TryGetValue(column, out ParameterExpression recordWrapper, out ParameterExpression dataReader, out int ordinal))
            {
                return(Expression.Condition(
                           Expression.Call(recordWrapper, MethodCache.IsDbNull, dataReader, Expression.Constant(ordinal)),
                           Expression.Constant(outer.Type.GetDefaultValue(), outer.Type),
                           expr
                           ));
            }

            return(expr);
        }
Ejemplo n.º 6
0
        protected override Expression VisitOuterJoined(OuterJoinedExpression outer)
        {
            Expression          expr   = this.Visit(outer.Expression);
            ColumnExpression    column = (ColumnExpression)outer.Test;
            ParameterExpression reader;
            int iOrdinal;

            if (this.scope.TryGetValue(column, out reader, out iOrdinal))
            {
                return(Expression.Condition(
                           Expression.Call(reader, "IsDbNull", null, Expression.Constant(iOrdinal)),
                           Expression.Constant(UWay.Skynet.Cloud.Reflection.TypeHelper.GetDefault(outer.Type), outer.Type),
                           expr
                           ));
            }
            return(expr);
        }
Ejemplo n.º 7
0
        protected override Expression VisitOuterJoined(OuterJoinedExpression outer)
        {
            Expression          expr   = this.Visit(outer.Expression);
            ColumnExpression    column = (ColumnExpression)outer.Test;
            ParameterExpression recordWrapper;
            ParameterExpression dataReader;
            int ordinal;

            if (this.scope.TryGetValue(column, out recordWrapper, out dataReader, out ordinal))
            {
                return(Expression.Condition(
                           Expression.Call(recordWrapper, MthIsDbNull, dataReader, Expression.Constant(ordinal)),
                           Expression.Constant(outer.Type.GetDefaultValue(), outer.Type),
                           expr
                           ));
            }

            return(expr);
        }
Ejemplo n.º 8
0
 protected virtual Expression VisitOuterJoined(OuterJoinedExpression outer)
 {
     this.Write("Outer(");
     this.WriteLine(Indentation.Inner);
     this.Visit(outer.Test);
     this.Write(", ");
     this.WriteLine(Indentation.Same);
     this.Visit(outer.Expression);
     this.WriteLine(Indentation.Outer);
     this.Write(")");
     return outer;
 }
Ejemplo n.º 9
0
 protected virtual Expression VisitOuterJoined(OuterJoinedExpression outer)
 {
     Expression test = this.Visit(outer.Test);
     Expression expression = this.Visit(outer.Expression);
     if (test != outer.Test || expression != outer.Expression)
     {
         return new OuterJoinedExpression(test, expression);
     }
     return outer;
 }
Ejemplo n.º 10
0
        internal static Expression BindMember(Expression source, MemberInfo member)
        {
            switch (source.NodeType)
            {
            case ExpressionType.MemberInit:
                MemberInitExpression min = (MemberInitExpression)source;
                for (int i = 0, n = min.Bindings.Count; i < n; i++)
                {
                    MemberAssignment assign = min.Bindings[i] as MemberAssignment;
                    if (assign != null && MembersMatch(assign.Member, member))
                    {
                        return(assign.Expression);
                    }
                }
                break;

            case ExpressionType.New:
                NewExpression nex = (NewExpression)source;
                if (nex.Members != null)
                {
                    for (int i = 0, n = nex.Members.Count; i < n; i++)
                    {
                        if (MembersMatch(nex.Members[i], member))
                        {
                            return(nex.Arguments[i]);
                        }
                    }
                }
                else if (nex.Type.IsGenericType && nex.Type.GetGenericTypeDefinition() == typeof(Grouping <,>))
                {
                    if (member.Name == "Key")
                    {
                        return(nex.Arguments[0]);
                    }
                }
                break;

            case (ExpressionType)DbExpressionType.Projection:
                // member access on a projection turns into a new projection w/ member access applied
                ProjectionExpression proj         = (ProjectionExpression)source;
                Expression           newProjector = BindMember(proj.Projector, member);
                return(new ProjectionExpression(proj.Source, newProjector));

            case (ExpressionType)DbExpressionType.OuterJoined:
                OuterJoinedExpression oj = (OuterJoinedExpression)source;
                Expression            em = BindMember(oj.Expression, member);
                if (em is ColumnExpression)
                {
                    return(em);
                }
                return(new OuterJoinedExpression(oj.Test, em));

            case ExpressionType.Conditional:
                ConditionalExpression cex = (ConditionalExpression)source;
                return(Expression.Condition(cex.Test, BindMember(cex.IfTrue, member),
                                            BindMember(cex.IfFalse, member)));

            case ExpressionType.Constant:
                ConstantExpression con = (ConstantExpression)source;
                if (con.Value == null)
                {
                    Type memberType = TypeHelper.GetMemberType(member);
                    return(Expression.Constant(GetDefault(memberType), memberType));
                }
                break;
            }
            return(Expression.MakeMemberAccess(source, member));
        }
Ejemplo n.º 11
0
 protected override Expression VisitOuterJoined(OuterJoinedExpression outer)
 {
     Expression expr = Visit(outer.Expression);
     ColumnExpression column = (ColumnExpression)outer.Test;
     ParameterExpression reader;
     int iOrdinal;
     if (scope.TryGetValue(column, out reader, out iOrdinal))
     {
         return Expression.Condition(
             Expression.Call(reader, "IsDbNull", null, Expression.Constant(iOrdinal)),
             Expression.Constant(null, outer.Type),
             expr
             );
     }
     return expr;
 }
Ejemplo n.º 12
0
 protected virtual Expression VisitOuterJoined(OuterJoinedExpression outer)
 {
     var test = this.Visit(outer.Test);
     var expression = this.Visit(outer.Expression);
     return this.UpdateOuterJoined(outer, test, expression);
 }
Ejemplo n.º 13
0
 protected OuterJoinedExpression UpdateOuterJoined(OuterJoinedExpression outer, Expression test, Expression expression)
 {
     if (test != outer.Test || expression != outer.Expression)
     {
         return new OuterJoinedExpression(test, expression);
     }
     return outer;
 }
Ejemplo n.º 14
0
        public static Expression BindMember(Expression source, MemberInfo member)
        {
            switch (source.NodeType)
            {
            case (ExpressionType)DbExpressionType.Entity:
                EntityExpression ex  = (EntityExpression)source;
                var result           = BindMember(ex.Expression, member);
                MemberExpression mex = result as MemberExpression;
                if (mex != null && mex.Expression == ex.Expression && mex.Member == member)
                {
                    return(Expression.MakeMemberAccess(source, member));
                }
                return(result);

            case ExpressionType.Convert:
                UnaryExpression ux = (UnaryExpression)source;
                return(BindMember(ux.Operand, member));

            case ExpressionType.MemberInit:
                MemberInitExpression min = (MemberInitExpression)source;
                for (int i = 0, n = min.Bindings.Count; i < n; i++)
                {
                    MemberAssignment assign = min.Bindings[i] as MemberAssignment;
                    if (assign != null && MembersMatch(assign.Member, member))
                    {
                        return(assign.Expression);
                    }
                }
                break;

            case ExpressionType.New:
                NewExpression nex = (NewExpression)source;
                if (nex.Members != null)
                {
                    for (int i = 0, n = nex.Members.Count; i < n; i++)
                    {
                        if (MembersMatch(nex.Members[i], member))
                        {
                            return(nex.Arguments[i]);
                        }
                    }
                }
                else if (nex.Type.IsGenericType && nex.Type.GetGenericTypeDefinition() == typeof(Grouping <,>))
                {
                    if (member.Name == "Key")
                    {
                        return(nex.Arguments[0]);
                    }
                }
                break;

            case (ExpressionType)DbExpressionType.Projection:
                // member access on a projection turns into a new projection w/ member access applied
                ProjectionExpression proj         = (ProjectionExpression)source;
                Expression           newProjector = BindMember(proj.Projector, member);
                Type mt = TypeHelper.GetMemberType(member);
                return(new ProjectionExpression(proj.Select, newProjector, Aggregator.GetAggregator(mt, typeof(IEnumerable <>).MakeGenericType(mt))));

            case (ExpressionType)DbExpressionType.OuterJoined:
                OuterJoinedExpression oj = (OuterJoinedExpression)source;
                Expression            em = BindMember(oj.Expression, member);
                if (em is ColumnExpression)
                {
                    return(em);
                }
                return(new OuterJoinedExpression(oj.Test, em));

            case ExpressionType.Conditional:
                ConditionalExpression cex = (ConditionalExpression)source;
                return(Expression.Condition(cex.Test, BindMember(cex.IfTrue, member), BindMember(cex.IfFalse, member)));

            case ExpressionType.Constant:
                ConstantExpression con = (ConstantExpression)source;
                Type memberType        = TypeHelper.GetMemberType(member);
                if (con.Value == null)
                {
                    return(Expression.Constant(GetDefault(memberType), memberType));
                }
                else
                {
                    return(Expression.Constant(GetValue(con.Value, member), memberType));
                }
            }
            return(Expression.MakeMemberAccess(source, member));
        }