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());
}
