public void TestFindMemberExpressionReference() { Expression <Func <Person, string> > e = (Person p) => p.Name; string property = ExpressionProcessor.FindMemberExpression(e.Body); Assert.AreEqual("Name", property); }
public static ICriterion ProcessIsLike(MethodCallExpression methodCallExpression) { string property = ExpressionProcessor.FindMemberExpression(methodCallExpression.Arguments[0]); object value = ExpressionProcessor.FindValue(methodCallExpression.Arguments[1]); return(Restrictions.Like(property, value)); }
public static ICriterion ProcessIsInCollection(MethodCallExpression methodCallExpression) { string property = ExpressionProcessor.FindMemberExpression(methodCallExpression.Arguments[0]); ICollection values = (ICollection)ExpressionProcessor.FindValue(methodCallExpression.Arguments[1]); return(Restrictions.In(property, values)); }
internal static IProjection ProcessAsEntity(MethodCallExpression methodCallExpression) { var expression = methodCallExpression.Arguments[0]; var aliasName = ExpressionProcessor.FindMemberExpression(expression); return(Projections.Entity(expression.Type, aliasName)); }
private Property GetProperty <TOut>(Expression <Func <T, TOut> > expression, string columnName) { var property = ExpressionProcessor <T> .FindMemberExpression(expression); property.ColumnName = Dialect.EscapeColumn(columnName ?? property.Name); return(property); }
public void TestFindMemberExpressionValue() { Expression <Func <Person, object> > e = (Person p) => p.Age; string property = ExpressionProcessor.FindMemberExpression(e.Body); Assert.AreEqual("Age", property); }
public void TestFindMemberExpressionSubCollectionExtensionMethod() { Expression <Func <Person, object> > e = (Person p) => p.PersonList.First().Children; string property = ExpressionProcessor.FindMemberExpression(e.Body); Assert.AreEqual("PersonList.Children", property); }
protected IQueryOver <T, T> CreateTestQueryOver <T>(Expression <Func <object> > alias) { string aliasContainer = ExpressionProcessor.FindMemberExpression(alias.Body); return((IQueryOver <T, T>) typeof(QueryOver <T, T>).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new System.Type[] { typeof(CriteriaImpl) }, null) .Invoke(new object[] { new CriteriaImpl(typeof(T), aliasContainer, null) })); }
WhereSpatialRestrictionOn <TRoot, TSubType>( this IQueryOver <TRoot, TSubType> root, Expression <Func <TSubType, object> > expression) { return(new QueryOverSpatialRestrictionBuilder <TRoot, TSubType>( root, ExpressionProcessor.FindMemberExpression(expression.Body))); }
public static ICriterion ProcessIsLikeMatchMode(MethodCallExpression methodCallExpression) { string property = ExpressionProcessor.FindMemberExpression(methodCallExpression.Arguments[0]); string value = (string)ExpressionProcessor.FindValue(methodCallExpression.Arguments[1]); MatchMode matchMode = (MatchMode)ExpressionProcessor.FindValue(methodCallExpression.Arguments[2]); return(Restrictions.Like(property, value, matchMode)); }
public IFilteredQueryOverFilterBuilder <TEntity> FilterBy(Expression <Func <TEntity, object> > memberExpression) { memberExpression.ThrowIfNull("memberExpression"); var property = ExpressionProcessor.FindMemberExpression(memberExpression.Body); return(FilterBy(property)); }
public static ICriterion ProcessIsBetween(MethodCallExpression methodCallExpression) { MethodCallExpression betweenFunction = (MethodCallExpression)methodCallExpression.Object; string property = ExpressionProcessor.FindMemberExpression(betweenFunction.Arguments[0]); object lo = ExpressionProcessor.FindValue(betweenFunction.Arguments[1]); object hi = ExpressionProcessor.FindValue(methodCallExpression.Arguments[0]); return(Restrictions.Between(property, lo, hi)); }
public IFilteredQueryOverNaturalIdFilterBuilder <TEntity> Without( params Expression <Func <TEntity, object> >[] memberExpressions) { memberExpressions.ThrowIfNull("memberExpressions"); var properties = memberExpressions.Select(x => ExpressionProcessor.FindMemberExpression(x.Body)).ToArray(); return(Without(properties)); }
/// <summary> /// 속성 < <paramref name="current"/> 인 질의를 추가합니다. (값이 <paramref name="current"/>보다 작다면, 이미 지나간 시간이라는 뜻) /// </summary> /// <typeparam name="T"></typeparam> /// <param name="query"></param> /// <param name="current"></param> /// <param name="expr"></param> /// <returns></returns> public static IQueryable <T> AddIsElapsed <T>(this IQueryable <T> query, DateTime current, Expression <Func <T, object> > expr) { query.ShouldNotBeNull("query"); expr.ShouldNotBeNull("expr"); var propertyName = ExpressionProcessor.FindMemberExpression(expr.Body); return(DynamicQueryable.Where(query, propertyName + " < @0", current)); }
protected QueryOverLockBuilderBase(TReturn root, Expression <Func <object> > alias) { this.root = root; if (alias != null) { this.alias = ExpressionProcessor.FindMemberExpression(alias.Body); } }
public IFilteredQueryOver <TEntity> Where(Expression <Func <TEntity, object> > memberExpression, ICriterion criterion) { memberExpression.ThrowIfNull("memberExpression"); criterion.ThrowIfNull("criterion"); var property = ExpressionProcessor.FindMemberExpression(memberExpression.Body); return(Where(property, criterion)); }
/// <summary> /// IQueryable{T}에 Between 조건을 추가합니다. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="query"></param> /// <param name="expr"></param> /// <param name="lo"></param> /// <param name="hi"></param> /// <returns></returns> public static IQueryable <T> AddBetween <T>(this IQueryable <T> query, Expression <Func <T, object> > expr, object lo, object hi) { query.ShouldNotBeNull("query"); var propertyName = ExpressionProcessor.FindMemberExpression(expr.Body); var betweenExpr = IsBetweenExpression(propertyName); return(DynamicQueryable.Where(query, betweenExpr, lo, hi)); }
internal static IProjection ProcessAsEntity(MethodCallExpression methodCallExpression) { var expression = methodCallExpression.Arguments[0]; var aliasName = ExpressionProcessor.FindMemberExpression(expression); return (string.IsNullOrEmpty(aliasName) ? Projections.RootEntity() : Projections.Entity(expression.Type, aliasName)); }
/// <summary> /// 지정한 속성 값이 NULL이면 True로 간주하는 Where 절을 추가한다. /// Explicit 하게 PropertyName = False 로 되어 있는 것을 제외한 True이거나 NULL 것은 True 로 간주한다. /// </summary> public static IQueryable <T> AddNullAsTrue <T>(this IQueryable <T> query, Expression <Func <T, object> > expr, bool?value) { var propertyName = ExpressionProcessor.FindMemberExpression(expr.Body); if (value.GetValueOrDefault(true) == false) { return(DynamicQueryable.Where(query, propertyName + " == @0", false)); } return(AddEqIncludeNull(query, expr, true)); }
/// <summary> /// 지정된 속성이 지정된 값과 같거나, 속성 값이 NULL인 경우 (예: Name=:Name OR Name IS NULL) /// </summary> public static IQueryable <T> AddEqIncludeNull <T>(this IQueryable <T> query, Expression <Func <T, object> > expr, object value) { query.ShouldNotBeNull("query"); expr.ShouldNotBeNull("expr"); var proeprtyName = ExpressionProcessor.FindMemberExpression(expr.Body); var exprString = string.Format("{0}==@0 || {0} == null", proeprtyName); return(DynamicQueryable.Where(query, exprString, value)); }
/// <summary> /// 값이 null 이라면 "속성 IS NULL" 을, 값이 있다면, "속성 = value" 라는 질의를 추가합니다. /// (예: value가 'RealWeb'인 경우 Company='RealWeb', value가 null인 경우 Company IS NULL) /// </summary> public static IQueryable <T> AddEqOrNull <T>(this IQueryable <T> query, Expression <Func <T, object> > expr, object value) { query.ShouldNotBeNull("query"); expr.ShouldNotBeNull("expr"); var propertyName = ExpressionProcessor.FindMemberExpression(expr.Body); var exprString = (value != null) ? propertyName + " == @0" : propertyName + " == null"; return(DynamicQueryable.Where(query, exprString, value)); }
/// <summary> /// IQueryable{T}에 InRange 조건을 추가합니다. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="query"></param> /// <param name="value"></param> /// <param name="loExpr"></param> /// <param name="hiExpr"></param> /// <returns></returns> public static IQueryable <T> AddInRange <T>(this IQueryable <T> query, object value, Expression <Func <T, object> > loExpr, Expression <Func <T, object> > hiExpr) { query.ShouldNotBeNull("query"); var loPropertyName = ExpressionProcessor.FindMemberExpression(loExpr.Body); var hiPropertyName = ExpressionProcessor.FindMemberExpression(hiExpr.Body); var isInRangeExpr = IsInRangeExpression(loPropertyName, hiPropertyName); return(DynamicQueryable.Where(query, isInRangeExpr, value)); }
public ProjectionList ToProjections() { var projectionList = Projections.ProjectionList(); foreach (var map in Maps) { var name = ExpressionProcessor.FindMemberExpression(map.Item2.Body); projectionList.Add(Projections.Property(map.Item1), name); } return(projectionList); }
/// <summary> /// Converte as projections com usando o mesmo nome da propriedade. /// </summary> /// <typeparam name="TE">tipo</typeparam> /// <param name="projections">projetions</param> /// <returns>projections usando o mesmo nome da propriedade</returns> public static ProjectionList ToProjections <TE>(params Expression <Func <TE, object> >[] projections) { var projectionList = Projections.ProjectionList(); foreach (var expression in projections) { var name = ExpressionProcessor.FindMemberExpression(expression.Body); projectionList.Add(Projections.Property(expression), name); } return(projectionList); }
public DictionaryMappingResultTransformer(IDictionary <string, Expression <Func <TResultType, object> > > mapping) { this.memberInfoMapping = new Dictionary <string, MemberInfo>(); foreach (string key in mapping.Keys) { string memberName = ExpressionProcessor.FindMemberExpression(mapping[key].Body); MemberInfo memberInfo = this.ResultType.GetProperty(memberName) ?? (MemberInfo)this.ResultType.GetField(memberName); this.memberInfoMapping.Add(key, memberInfo); } }
/// <summary> /// 람다 식에서 정의한 속성 명을 문자열로 가져옵니다. (QueryOver 의 Lambda Expr 에서 속성명을 추출해서, ICriterion 으로 변환할 수 있습니다) /// </summary> /// <typeparam name="T"></typeparam> /// <param name="expression"></param> /// <returns></returns> public static string RetrievePropertyName <T>(this Expression <Func <T, object> > expression) { if (IsDebugEnabled) { log.Debug("속성명을 추출할 람다식=[{0}]", expression.Body); } var propertyName = ExpressionProcessor.FindMemberExpression(expression.Body); if (IsDebugEnabled) { log.Debug("람다식에서 속성명을 추출했습니다. 람다식=[{0}], propertyName=[{1}]", expression.Body, propertyName); } return(propertyName); }
/// <summary> /// 원본 객체를 대상 객체로 매핑합니다. <paramref name="additionalMapping"/>을 통해 추가적인 매핑을 수행할 수 있습니다. /// </summary> /// <typeparam name="TSource">원본 객체 형식</typeparam> /// <typeparam name="TTarget">대상 객체 형식</typeparam> /// <param name="source">원본 객체</param> /// <param name="targetFactory">대상 객체 생성 Factory</param> /// <param name="mapOptions">매핑 옵션</param> /// <param name="additionalMapping">추가 매핑 함수</param> /// <param name="propertyExprsToExclude">매핑에서 제외할 속성 표현식</param> /// <returns>대상 객체 시퀀스</returns> public static TTarget MapEntity <TSource, TTarget>(this TSource source, Func <TTarget> targetFactory, MapPropertyOptions mapOptions, Action <TSource, TTarget> additionalMapping, params Expression <Func <TTarget, object> >[] propertyExprsToExclude) { targetFactory.ShouldNotBeNull("targetFactory"); var propertyNamesToExclude = propertyExprsToExclude.Select(expr => ExpressionProcessor.FindMemberExpression(expr.Body)).ToList(); ExcludeStatePropertyForStateEntity <TSource>(propertyNamesToExclude); return(ObjectMapper.MapObject <TSource, TTarget>(source, targetFactory, mapOptions, additionalMapping, propertyNamesToExclude.ToArray())); }
// here: WhereLikeCiAi() public static IQueryOver <TRoot, TSubType> WhereLikeCiAi <TRoot, TSubType>( this IQueryOver <TRoot, TSubType> query , Expression <Func <TSubType, object> > expression , string value , MatchMode matchMode) { var name = ExpressionProcessor.FindMemberExpression(expression.Body); query .UnderlyingCriteria .Add ( new LikeCollationExpression(name, value, matchMode) ); return(query); }
/// <summary> /// Applies a select mode for the given aliased criteria association paths: /// <c>() => aliasedCriteria</c> or <c>() => aliasedCriteria.ChildEntity.SubEntity</c>. /// </summary> public static TThis Fetch <TThis>( this TThis queryOver, SelectMode mode, params Expression <Func <object> >[] aliasedAssociationPaths) where TThis : IQueryOver { var criteria = queryOver.UnderlyingCriteria; foreach (var aliasedPath in aliasedAssociationPaths) { var expressionPath = ExpressionProcessor.FindMemberExpression(aliasedPath.Body); StringHelper.IsNotRoot(expressionPath, out var alias, out var path); criteria.Fetch(mode, path, alias); } return(queryOver); }
/// <summary> /// 원본 객체를 대상 객체로 매핑합니다. <paramref name="additionalMapping"/>을 통해 추가적인 매핑을 수행할 수 있습니다. /// </summary> /// <typeparam name="TSource">원본 객체 형식</typeparam> /// <typeparam name="TTarget">대상 객체 형식</typeparam> /// <param name="sources">원본 객체 시퀀스</param> /// <param name="targetFactory">대상 객체 생성 Factory</param> /// <param name="mapOptions">매핑 옵션</param> /// <param name="additionalMapping">추가 매핑 함수</param> /// <param name="propertyExprsToExclude">매핑에서 제외할 속성 표현식</param> /// <returns>대상 객체 시퀀스</returns> public static IList <TTarget> MapEntitiesAsParallel <TSource, TTarget>(this IList <TSource> sources, Func <TTarget> targetFactory, MapPropertyOptions mapOptions, Action <TSource, TTarget> additionalMapping, params Expression <Func <TTarget, object> >[] propertyExprsToExclude) { if (IsDebugEnabled) { log.Debug("원본 엔티티[{0}] 컬렉션으로부터 대상 엔티티[{1}] 컬렉션으로 매핑을 수행합니다...", typeof(TSource).Name, typeof(TTarget).Name); } targetFactory.ShouldNotBeNull("targetFactory"); if (sources.Count == 0) { return(new List <TTarget>()); } var propertyNamesToExclude = propertyExprsToExclude.Select(expr => ExpressionProcessor.FindMemberExpression(expr.Body)).ToList(); ExcludeStatePropertyForStateEntity <TSource>(propertyNamesToExclude); // Source가 NHibernate 엔티티라면, Initialize를 통해, Lazy된 Proxy 값을 실제값으로 빌드합니다. // IList <TSource> initializedSources = sources; if (typeof(TSource).HasInterface(typeof(IStateEntity))) { if (IsDebugEnabled) { log.Debug("원본 객체가 NHibernate Entity이므로, Initialize를 수행합니다..."); } initializedSources = NHTool.InitializeEntities(sources, sources[0].IsDynamicProxy()); } return (ObjectMapper .MapObjectsAsParallel(initializedSources, targetFactory, mapOptions, additionalMapping, propertyNamesToExclude.ToArray()) .ToList()); }