/// <summary> /// Adds the specified property to the projection list. /// </summary> /// <param name="list"> /// The projection list. /// </param> /// <param name="property"> /// The property. /// </param> /// <param name="data"> /// A <see cref="QueryHelperData" /> instance. /// </param> /// <typeparam name="TSource"> /// The <see cref="System.Type" /> of the source entity. /// </typeparam> /// <typeparam name="TProperty"> /// The <see cref="System.Type" /> of the property. /// </typeparam> /// <returns> /// The <see cref="ProjectionList" /> instance. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="list" /> is null. /// </exception> public static ProjectionList AddProperty <TSource, TProperty> ( this ProjectionList list, Expression <Func <TSource, TProperty> > property, QueryHelperData data ) { if (list == null) { throw new ArgumentNullException("list"); } IProjection projection = ProjectionHelper.GetProjection(property, data); string alias = null; var propertyProjection = projection as IPropertyProjection; if (propertyProjection != null) { alias = propertyProjection.PropertyName; } list.Add(projection, alias); return(list); }
/// <inheritdoc /> public virtual TQuery GroupBy(Expression <Func <TSource, object> > property) { if (property != null) { IProjection projection = ProjectionHelper .GetProjection ( property.Body, new HelperContext(Data, property, HelperType.GroupBy) ); if (projection != null) { if (projection.IsGrouped || projection.IsAggregate) { throw new InvalidOperationException( "Cannot use an aggregate or grouped projection with GroupBy"); } GroupBys.Add(new FqGroupByProjection(projection, false)); } } return(Query); }
/// <inheritdoc /> public override IProjection Project ( Expression expression, HelperContext context ) { return(ProjectionHelper.GetProjection(((LambdaExpression)expression).Body, context)); }
public IProjection Project ( Expression expression, HelperContext context ) { var methodCall = (MethodCallExpression)expression; return(ProjectionHelper.GetProjection(methodCall.Object, context)); }
/// <inheritdoc /> public override IProjection Project ( Expression expression, HelperContext context ) { var memberInit = (MemberInitExpression)expression; var list = Projections.ProjectionList(); var newProjection = ProjectionHelper.GetProjection(memberInit.NewExpression, context) as ProjectionList; if (newProjection != null) { for (int i = 0; i < newProjection.Length; i++) { list.Add(newProjection[i]); } } foreach (MemberBinding memberBinding in memberInit.Bindings) { var memberAssigment = memberBinding as MemberAssignment; if (memberAssigment != null) { IProjection projection = ProjectionHelper.GetProjection(memberAssigment.Expression, context); var innerList = projection as ProjectionList; if (innerList != null) { for (int i = 0; i < innerList.Length; i++) { list.Add(innerList[i]); } } else { string member = memberAssigment.Member.Name; list.Add(new FqAliasProjection(projection, member)); if (!context.Data.Mappings.ContainsKey(member)) { context.Data.Mappings.Add(member, projection); } } } } return(list); }
/// <inheritdoc /> public override IProjection Project(Expression expression, HelperContext context) { var condition = (ConditionalExpression)expression; return(Projections .Conditional ( RestrictionHelper.GetCriterion(condition.Test, context), ProjectionHelper.GetProjection(condition.IfTrue, context), ProjectionHelper.GetProjection(condition.IfFalse, context) )); }
/// <inheritdoc /> public override IProjection Project ( Expression expression, HelperContext context ) { var binary = (BinaryExpression)expression; IProjection original = ProjectionHelper.GetProjection(binary.Left, context); IProjection fallback = ProjectionHelper.GetProjection(binary.Right, context); return(Projections.Conditional(Restrictions.IsNull(original), fallback, original)); }
/// <inheritdoc /> public override IProjection Project ( Expression expression, HelperContext context ) { var methodCall = (MethodCallExpression)expression; Expression subExpression = methodCall.Object ?? methodCall.Arguments[0]; IProjection projection = ProjectionHelper.GetProjection(subExpression, context); return(ProjectCore(methodCall, subExpression, projection, context)); }
/// <inheritdoc /> public virtual ISelectSetup <TSource, TDestination> Use <TProjection> ( Expression <Func <TSource, TProjection> > expression ) { if (expression == null) { throw new ArgumentNullException("expression"); } IProjection projection = ProjectionHelper .GetProjection(expression, Data); return(Use(projection)); }
/// <inheritdoc /> public virtual TQuery OrderBy ( Expression <Func <TSource, object> > property, bool ascending = true ) { IProjection projection = ProjectionHelper .GetProjection ( property.Body, new HelperContext(Data, property, HelperType.Order) ); return(OrderBy(projection, ascending)); }
/// <inheritdoc /> public override IProjection Project ( Expression expression, HelperContext context ) { string operation = GetArithmeticOperation(expression.NodeType); var binary = (BinaryExpression)expression; return(new SqlFunctionProjection ( new VarArgsSQLFunction("(", operation, ")"), NHibernateUtil.GuessType(binary.Left.Type), ProjectionHelper.GetProjection(binary.Left, context), ProjectionHelper.GetProjection(binary.Right, context) )); }
/// <inheritdoc /> public override IProjection Project ( Expression expression, HelperContext context ) { var projections = new List <IProjection>(); var binary = (BinaryExpression)expression; foreach (Expression expressionPart in binary.Flatten()) { IProjection projection = ProjectionHelper.GetProjection(expressionPart, context); projections.Add(projection); } return(new SqlFunctionProjection("concat", NHibernateUtil.String, projections.ToArray())); }
/// <inheritdoc /> public override IProjection Project ( Expression expression, HelperContext context ) { var unary = (UnaryExpression)expression; IProjection projection = ProjectionHelper.GetProjection(unary.Operand, context); if (!unary.IsLiftedToNull) { IType type = TypeHelper.GuessType(unary.Type, true); if (type != null) { return(new FqCastProjection(type, projection)); } } return(projection); }
/// <inheritdoc /> protected override IProjection ProjectCore ( MethodCallExpression expression, Expression subExpression, IProjection projection, HelperContext context ) { var fromExpression = ExpressionHelper.GetValue <LambdaExpression>(expression.Arguments[1]); if (fromExpression == null) { return(null); } string tempRoot = context.RootAlias; context.RootAlias = fromExpression.Parameters[0].Name; if (context.Data.Aliases.ContainsValue(context.RootAlias)) { // if the parameter to the mapping expression is the same as a joined alias we do not want it to be // treated as the "expected root" as it would cause properties in the map to be resolved from the query // root entity, when the map might actually be for a joined alias. context.RootAlias = "null"; } //// TODO: Might want to check if (original) rootName != alias (e.g. expression.Arguments[0]) //// if that is the case we might have to change the parameter name in the mapping expression so that the //// projections can be properly resolved. IProjection result = ProjectionHelper .GetProjection(fromExpression, context); context.RootAlias = tempRoot; return(result); }
public IProjection Project ( Expression expression, HelperContext context ) { var methodCall = (MethodCallExpression)expression; // return null if called statically if (methodCall.Object == null) { return(null); } // return null if called for non-ToString method if (methodCall.Method.Name != "ToString") { return(null); } // resolve a projection for the property IProjection property = ProjectionHelper .GetProjection(methodCall.Object, context); // return null if no projection could be resolved if (property == null) { return(null); } // create a cast projection property return(new CastProjection ( NHibernateUtil.String, property )); }
/// <summary> /// Specifies an expression to project. /// </summary> /// <param name="expression"> /// The expression. /// </param> /// <typeparam name="TDestination"> /// The <see cref="System.Type" /> of the result. /// </typeparam> /// <returns> /// The <see cref="T:TQuery" />. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="expression" /> is null. /// </exception> protected virtual TQuery Project <TDestination>(Expression <Func <TSource, TDestination> > expression) { if (expression == null) { throw new ArgumentNullException("expression"); } IProjection list = ProjectionHelper .GetProjection ( expression, Data ); if (list == null || (list is ProjectionList && ((ProjectionList)list).Length == 0)) { throw new NotSupportedException ( "The provided expression contains unsupported features please revise your code." ); } return(ProjectionBase <TDestination>(list, Data.Mappings, expression, false)); }