public virtual IQueryState Accept(AggregateQueryExpression exp)
{
List <DbExpression> dbArguments = new List <DbExpression>(exp.Arguments.Count);
foreach (Expression argument in exp.Arguments)
{
var arg = (LambdaExpression)argument;
ScopeParameterDictionary scopeParameters = this._resultElement.ScopeParameters.Clone(arg.Parameters[0], this._resultElement.MappingObjectExpression);
var dbArgument = GeneralExpressionVisitor.ParseLambda(arg, scopeParameters, this._resultElement.ScopeTables);
dbArguments.Add(dbArgument);
}
DbAggregateExpression dbAggregateExp = new DbAggregateExpression(exp.ElementType, exp.Method, dbArguments);
MappingFieldExpression mfe = new MappingFieldExpression(exp.ElementType, dbAggregateExp);
ResultElement result = new ResultElement(this._resultElement.ScopeParameters, this._resultElement.ScopeTables);
result.MappingObjectExpression = mfe;
result.FromTable = this._resultElement.FromTable;
result.AppendCondition(this._resultElement.Condition);
AggregateQueryState state = new AggregateQueryState(result);
return(state);
}
static DbExpression ParseFilter(QueryModel queryModel, LambdaExpression filter)
{
ScopeParameterDictionary scopeParameters = queryModel.ScopeParameters.Clone(filter.Parameters[0], queryModel.ResultModel);
DbExpression filterCondition = FilterPredicateParser.Parse(filter, scopeParameters, queryModel.ScopeTables);
return(filterCondition);
}
public virtual IQueryState Accept(AggregateQueryExpression exp)
{
List <DbExpression> dbArguments = new List <DbExpression>(exp.Arguments.Count);
foreach (Expression argument in exp.Arguments)
{
var arg = (LambdaExpression)argument;
ScopeParameterDictionary scopeParameters = this._queryModel.ScopeParameters.Clone(arg.Parameters[0], this._queryModel.ResultModel);
var dbArgument = GeneralExpressionParser.Parse(arg, scopeParameters, this._queryModel.ScopeTables);
dbArguments.Add(dbArgument);
}
DbAggregateExpression dbAggregateExp = new DbAggregateExpression(exp.ElementType, exp.Method, dbArguments);
PrimitiveObjectModel resultModel = new PrimitiveObjectModel(exp.ElementType, dbAggregateExp);
QueryModel queryModel = new QueryModel(this._queryModel.ScopeParameters, this._queryModel.ScopeTables, this._queryModel.IgnoreFilters);
queryModel.ResultModel = resultModel;
queryModel.FromTable = this._queryModel.FromTable;
queryModel.AppendCondition(this._queryModel.Condition);
AggregateQueryState state = new AggregateQueryState(queryModel);
return(state);
}
JoinQueryExpressionResolver(QueryModel queryModel, JoinType joinType, LambdaExpression conditionExpression, ScopeParameterDictionary scopeParameters)
{
this._queryModel = queryModel;
this._joinType = joinType;
this._conditionExpression = conditionExpression;
this._scopeParameters = scopeParameters;
}
JoinQueryExpressionVisitor(ResultElement resultElement, JoinType joinType, LambdaExpression conditionExpression, ScopeParameterDictionary scopeParameters)
{
this._resultElement = resultElement;
this._joinType = joinType;
this._conditionExpression = conditionExpression;
this._scopeParameters = scopeParameters;
}
public virtual IQueryState Accept(WhereExpression exp)
{
ScopeParameterDictionary scopeParameters = this._resultElement.ScopeParameters.Clone(exp.Predicate.Parameters[0], this._resultElement.MappingObjectExpression);
DbExpression whereCondition = FilterPredicateExpressionVisitor.ParseFilterPredicate(exp.Predicate, scopeParameters, this._resultElement.ScopeTables);
this._resultElement.AppendCondition(whereCondition);
return this;
}
public virtual IQueryState Accept(WhereExpression exp)
{
ScopeParameterDictionary scopeParameters = this._queryModel.ScopeParameters.Clone(exp.Predicate.Parameters[0], this._queryModel.ResultModel);
DbExpression whereCondition = FilterPredicateParser.Parse(exp.Predicate, scopeParameters, this._queryModel.ScopeTables);
this._queryModel.AppendCondition(whereCondition);
return(this);
}
public virtual QueryModel CreateNewQueryModel(LambdaExpression selector)
{
QueryModel newQueryModel = this._queryModel.Clone();
ScopeParameterDictionary scopeParameters = this._queryModel.ScopeParameters.Clone(selector.Parameters[0], this._queryModel.ResultModel);
IObjectModel newResultModel = SelectorResolver.Resolve(selector, scopeParameters, this._queryModel.ScopeTables);
newQueryModel.ResultModel = newResultModel;
return(newQueryModel);
}
public virtual ResultElement CreateNewResult(LambdaExpression selector)
{
ResultElement result = new ResultElement(this._resultElement.ScopeParameters, this._resultElement.ScopeTables);
result.FromTable = this._resultElement.FromTable;
ScopeParameterDictionary scopeParameters = this._resultElement.ScopeParameters.Clone(selector.Parameters[0], this._resultElement.MappingObjectExpression);
IMappingObjectExpression r = SelectorExpressionVisitor.ResolveSelectorExpression(selector, scopeParameters, this._resultElement.ScopeTables);
result.MappingObjectExpression = r;
result.Orderings.AddRange(this._resultElement.Orderings);
result.AppendCondition(this._resultElement.Condition);
result.GroupSegments.AddRange(this._resultElement.GroupSegments);
result.AppendHavingCondition(this._resultElement.HavingCondition);
return result;
}
public virtual QueryModel CreateNewQueryModel(LambdaExpression selector)
{
QueryModel newQueryModel = this._queryModel.Clone();
ComplexObjectModel complexObjectModel = this._queryModel.ResultModel as ComplexObjectModel;
if (complexObjectModel != null)
{
complexObjectModel.SetupFilters(this._queryModel.IgnoreFilters);
}
ScopeParameterDictionary scopeParameters = this._queryModel.ScopeParameters.Clone(selector.Parameters[0], this._queryModel.ResultModel);
IObjectModel newResultModel = SelectorResolver.Resolve(selector, scopeParameters, this._queryModel.ScopeTables);
newQueryModel.ResultModel = newResultModel;
return(newQueryModel);
}
public virtual IQueryState Accept(GroupingQueryExpression exp)
{
foreach (LambdaExpression item in exp.GroupKeySelectors)
{
var keySelector = (LambdaExpression)item;
ScopeParameterDictionary scopeParameters = this._resultElement.ScopeParameters.Clone(keySelector.Parameters[0], this._resultElement.MappingObjectExpression);
var dbExp = GeneralExpressionVisitor.ParseLambda(keySelector, scopeParameters, this._resultElement.ScopeTables);
this._resultElement.GroupSegments.Add(dbExp);
}
foreach (LambdaExpression havingPredicate in exp.HavingPredicates)
{
ScopeParameterDictionary scopeParameters = this._resultElement.ScopeParameters.Clone(havingPredicate.Parameters[0], this._resultElement.MappingObjectExpression);
var havingCondition = FilterPredicateExpressionVisitor.ParseFilterPredicate(havingPredicate, scopeParameters, this._resultElement.ScopeTables);
this._resultElement.AppendHavingCondition(havingCondition);
}
if (exp.Orderings.Count > 0)
{
this._resultElement.Orderings.Clear();
this._resultElement.InheritOrderings = false;
for (int i = 0; i < exp.Orderings.Count; i++)
{
GroupingQueryOrdering groupOrdering = exp.Orderings[i];
ScopeParameterDictionary scopeParameters = this._resultElement.ScopeParameters.Clone(groupOrdering.KeySelector.Parameters[0], this._resultElement.MappingObjectExpression);
DbExpression orderingDbExp = GeneralExpressionVisitor.ParseLambda(groupOrdering.KeySelector, scopeParameters, this._resultElement.ScopeTables);
DbOrdering ordering = new DbOrdering(orderingDbExp, groupOrdering.OrderType);
this._resultElement.Orderings.Add(ordering);
}
}
var newResult = this.CreateNewResult(exp.Selector);
return(new GroupingQueryState(newResult));
}
protected DbOrdering ParseOrderExpression(OrderExpression orderExp)
{
ScopeParameterDictionary scopeParameters = this._resultElement.ScopeParameters.Clone(orderExp.KeySelector.Parameters[0], this._resultElement.MappingObjectExpression);
DbExpression dbExpression = GeneralExpressionVisitor.ParseLambda(orderExp.KeySelector, scopeParameters, this._resultElement.ScopeTables);
DbOrderType orderType;
if (orderExp.NodeType == QueryExpressionType.OrderBy || orderExp.NodeType == QueryExpressionType.ThenBy)
{
orderType = DbOrderType.Asc;
}
else if (orderExp.NodeType == QueryExpressionType.OrderByDesc || orderExp.NodeType == QueryExpressionType.ThenByDesc)
{
orderType = DbOrderType.Desc;
}
else
throw new NotSupportedException(orderExp.NodeType.ToString());
DbOrdering ordering = new DbOrdering(dbExpression, orderType);
return ordering;
}
public virtual IQueryState Accept(GroupingQueryExpression exp)
{
foreach (LambdaExpression item in exp.GroupKeySelectors)
{
var keySelector = (LambdaExpression)item;
ScopeParameterDictionary scopeParameters = this._queryModel.ScopeParameters.Clone(keySelector.Parameters[0], this._queryModel.ResultModel);
this._queryModel.GroupSegments.AddRange(GroupKeySelectorParser.Parse(keySelector, scopeParameters, this._queryModel.ScopeTables));
}
foreach (LambdaExpression havingPredicate in exp.HavingPredicates)
{
ScopeParameterDictionary scopeParameters = this._queryModel.ScopeParameters.Clone(havingPredicate.Parameters[0], this._queryModel.ResultModel);
var havingCondition = FilterPredicateParser.Parse(havingPredicate, scopeParameters, this._queryModel.ScopeTables);
this._queryModel.AppendHavingCondition(havingCondition);
}
if (exp.Orderings.Count > 0)
{
this._queryModel.Orderings.Clear();
this._queryModel.InheritOrderings = false;
for (int i = 0; i < exp.Orderings.Count; i++)
{
GroupingQueryOrdering groupOrdering = exp.Orderings[i];
ScopeParameterDictionary scopeParameters = this._queryModel.ScopeParameters.Clone(groupOrdering.KeySelector.Parameters[0], this._queryModel.ResultModel);
DbExpression orderingDbExp = GeneralExpressionParser.Parse(groupOrdering.KeySelector, scopeParameters, this._queryModel.ScopeTables);
DbOrdering ordering = new DbOrdering(orderingDbExp, groupOrdering.OrderType);
this._queryModel.Orderings.Add(ordering);
}
}
QueryModel newQueryModel = this.CreateNewQueryModel(exp.Selector);
return(new GroupingQueryState(newQueryModel));
}
static QueryModel CreateQueryModel(RootQueryExpression rootQueryExp, ScopeParameterDictionary scopeParameters, StringSet scopeTables, Func <string, string> tableAliasGenerator)
{
Type entityType = rootQueryExp.ElementType;
if (entityType.IsAbstract || entityType.IsInterface)
{
throw new ArgumentException("The type of input can not be abstract class or interface.");
}
QueryModel queryModel = new QueryModel(scopeParameters, scopeTables);
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(entityType);
DbTable dbTable = typeDescriptor.GenDbTable(rootQueryExp.ExplicitTable);
string alias = null;
if (tableAliasGenerator != null)
{
alias = tableAliasGenerator(dbTable.Name);
}
else
{
alias = queryModel.GenerateUniqueTableAlias(dbTable.Name);
}
queryModel.FromTable = CreateRootTable(dbTable, alias, rootQueryExp.Lock);
DbTable aliasTable = new DbTable(alias);
ComplexObjectModel model = typeDescriptor.GenObjectModel(aliasTable);
model.DependentTable = queryModel.FromTable;
queryModel.ResultModel = model;
ParseFilters(queryModel, typeDescriptor.Definition.Filters, rootQueryExp.ContextFilters);
return(queryModel);
}
protected DbOrdering ParseOrderExpression(OrderExpression orderExp)
{
ScopeParameterDictionary scopeParameters = this._queryModel.ScopeParameters.Clone(orderExp.KeySelector.Parameters[0], this._queryModel.ResultModel);
DbExpression dbExpression = GeneralExpressionParser.Parse(orderExp.KeySelector, scopeParameters, this._queryModel.ScopeTables);
DbOrderType orderType;
if (orderExp.NodeType == QueryExpressionType.OrderBy || orderExp.NodeType == QueryExpressionType.ThenBy)
{
orderType = DbOrderType.Asc;
}
else if (orderExp.NodeType == QueryExpressionType.OrderByDesc || orderExp.NodeType == QueryExpressionType.ThenByDesc)
{
orderType = DbOrderType.Desc;
}
else
{
throw new NotSupportedException(orderExp.NodeType.ToString());
}
DbOrdering ordering = new DbOrdering(dbExpression, orderType);
return(ordering);
}
public GeneralExpressionParser(ScopeParameterDictionary scopeParameters, StringSet scopeTables)
{
this._scopeParameters = scopeParameters;
this._scopeTables = scopeTables;
}
public virtual JoinQueryResult ToJoinQueryResult(JoinType joinType, LambdaExpression conditionExpression, ScopeParameterDictionary scopeParameters, KeyDictionary <string> scopeTables, string tableAlias)
{
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
string alias = tableAlias;
DbTableSegment tableSeg = new DbTableSegment(subQuery, alias, LockType.Unspecified);
DbTable table = new DbTable(tableSeg.Alias);
IMappingObjectExpression newMoe = this.Result.MappingObjectExpression.ToNewObjectExpression(sqlQuery, table);
scopeParameters[conditionExpression.Parameters[conditionExpression.Parameters.Count - 1]] = newMoe;
DbExpression condition = GeneralExpressionVisitor.ParseLambda(conditionExpression, scopeParameters, scopeTables);
DbJoinTableExpression joinTable = new DbJoinTableExpression(joinType.AsDbJoinType(), tableSeg, condition);
JoinQueryResult result = new JoinQueryResult();
result.MappingObjectExpression = newMoe;
result.JoinTable = joinTable;
return(result);
}
public virtual JoinQueryResult ToJoinQueryResult(JoinType joinType, LambdaExpression conditionExpression, ScopeParameterDictionary scopeParameters, StringSet scopeTables, string tableAlias)
{
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
string alias = tableAlias;
DbTableSegment tableSeg = new DbTableSegment(subQuery, alias, LockType.Unspecified);
DbJoinTableExpression joinTable = new DbJoinTableExpression(joinType.AsDbJoinType(), tableSeg);
DbTable aliasTable = new DbTable(tableSeg.Alias);
IObjectModel newModel = this.QueryModel.ResultModel.ToNewObjectModel(sqlQuery, aliasTable, joinTable);
scopeParameters[conditionExpression.Parameters[conditionExpression.Parameters.Count - 1]] = newModel;
DbExpression condition = GeneralExpressionParser.Parse(conditionExpression, scopeParameters, scopeTables);
joinTable.Condition = condition;
JoinQueryResult result = new JoinQueryResult();
result.ResultModel = newModel;
result.JoinTable = joinTable;
return(result);
}
public static JoinQueryResult VisitQueryExpression(QueryExpression queryExpression, ResultElement resultElement, JoinType joinType, LambdaExpression conditionExpression, ScopeParameterDictionary scopeParameters)
{
JoinQueryExpressionVisitor visitor = new JoinQueryExpressionVisitor(resultElement, joinType, conditionExpression, scopeParameters);
return(queryExpression.Accept(visitor));
}
public static IQueryState VisitQueryExpression(QueryExpression queryExpression, ScopeParameterDictionary scopeParameters, KeyDictionary <string> scopeTables)
{
QueryExpressionVisitor reducer = new QueryExpressionVisitor(scopeParameters, scopeTables);
return(queryExpression.Accept(reducer));
}
public override IQueryState Visit(JoinQueryExpression exp)
{
IQueryState qs = QueryExpressionVisitor.VisitQueryExpression(exp.PrevExpression, this._scopeParameters, this._scopeTables);
ResultElement resultElement = qs.ToFromQueryResult();
List <IMappingObjectExpression> moeList = new List <IMappingObjectExpression>();
moeList.Add(resultElement.MappingObjectExpression);
foreach (JoiningQueryInfo joiningQueryInfo in exp.JoinedQueries)
{
ScopeParameterDictionary scopeParameters = resultElement.ScopeParameters.Clone(resultElement.ScopeParameters.Count + moeList.Count);
for (int i = 0; i < moeList.Count; i++)
{
ParameterExpression p = joiningQueryInfo.Condition.Parameters[i];
scopeParameters[p] = moeList[i];
}
JoinQueryResult joinQueryResult = JoinQueryExpressionVisitor.VisitQueryExpression(joiningQueryInfo.Query.QueryExpression, resultElement, joiningQueryInfo.JoinType, joiningQueryInfo.Condition, scopeParameters);
var nullChecking = DbExpression.CaseWhen(new DbCaseWhenExpression.WhenThenExpressionPair(joinQueryResult.JoinTable.Condition, DbConstantExpression.One), DbConstantExpression.Null, DbConstantExpression.One.Type);
if (joiningQueryInfo.JoinType == JoinType.LeftJoin)
{
joinQueryResult.MappingObjectExpression.SetNullChecking(nullChecking);
}
else if (joiningQueryInfo.JoinType == JoinType.RightJoin)
{
foreach (IMappingObjectExpression item in moeList)
{
item.SetNullChecking(nullChecking);
}
}
else if (joiningQueryInfo.JoinType == JoinType.FullJoin)
{
joinQueryResult.MappingObjectExpression.SetNullChecking(nullChecking);
foreach (IMappingObjectExpression item in moeList)
{
item.SetNullChecking(nullChecking);
}
}
resultElement.FromTable.JoinTables.Add(joinQueryResult.JoinTable);
moeList.Add(joinQueryResult.MappingObjectExpression);
}
ScopeParameterDictionary scopeParameters1 = resultElement.ScopeParameters.Clone(resultElement.ScopeParameters.Count + moeList.Count);
for (int i = 0; i < moeList.Count; i++)
{
ParameterExpression p = exp.Selector.Parameters[i];
scopeParameters1[p] = moeList[i];
}
IMappingObjectExpression moe = SelectorExpressionVisitor.ResolveSelectorExpression(exp.Selector, scopeParameters1, resultElement.ScopeTables);
resultElement.MappingObjectExpression = moe;
GeneralQueryState queryState = new GeneralQueryState(resultElement);
return(queryState);
}
public static DbExpression ParseLambda(LambdaExpression lambda, ScopeParameterDictionary scopeParameters, KeyDictionary <string> scopeTables)
{
GeneralExpressionVisitor visitor = new GeneralExpressionVisitor(scopeParameters, scopeTables);
return(visitor.Visit(lambda));
}
QueryExpressionVisitor(ScopeParameterDictionary scopeParameters, KeyDictionary <string> scopeTables)
{
this._scopeParameters = scopeParameters;
this._scopeTables = scopeTables;
}
public GeneralExpressionVisitor(LambdaExpression lambda, ScopeParameterDictionary scopeParameters, KeyDictionary <string> scopeTables) : this(scopeParameters, scopeTables)
{
this._lambda = lambda;
}
public static JoinQueryResult Resolve(QueryExpression queryExpression, QueryModel queryModel, JoinType joinType, LambdaExpression conditionExpression, ScopeParameterDictionary scopeParameters)
{
JoinQueryExpressionResolver resolver = new JoinQueryExpressionResolver(queryModel, joinType, conditionExpression, scopeParameters);
return(queryExpression.Accept(resolver));
}
public static IQueryState Resolve(QueryExpression queryExpression, ScopeParameterDictionary scopeParameters, KeyDictionary <string> scopeTables)
{
QueryExpressionResolver resolver = new QueryExpressionResolver(scopeParameters, scopeTables);
return(queryExpression.Accept(resolver));
}
public override IQueryState Visit(JoinQueryExpression exp)
{
IQueryState qs = QueryExpressionResolver.Resolve(exp.PrevExpression, this._scopeParameters, this._scopeTables);
QueryModel queryModel = qs.ToFromQueryModel();
List <IObjectModel> modelList = new List <IObjectModel>();
modelList.Add(queryModel.ResultModel);
foreach (JoinQueryInfo joinQueryInfo in exp.JoinedQueries)
{
ScopeParameterDictionary scopeParameters = queryModel.ScopeParameters.Clone(queryModel.ScopeParameters.Count + modelList.Count);
for (int i = 0; i < modelList.Count; i++)
{
ParameterExpression p = joinQueryInfo.Condition.Parameters[i];
scopeParameters[p] = modelList[i];
}
JoinQueryResult joinQueryResult = JoinQueryExpressionResolver.Resolve(joinQueryInfo, queryModel, scopeParameters);
var nullChecking = DbExpression.CaseWhen(new DbCaseWhenExpression.WhenThenExpressionPair(joinQueryResult.JoinTable.Condition, DbConstantExpression.One), DbConstantExpression.Null, DbConstantExpression.One.Type);
if (joinQueryInfo.JoinType == JoinType.LeftJoin)
{
joinQueryResult.ResultModel.SetNullChecking(nullChecking);
}
else if (joinQueryInfo.JoinType == JoinType.RightJoin)
{
foreach (IObjectModel item in modelList)
{
item.SetNullChecking(nullChecking);
}
}
else if (joinQueryInfo.JoinType == JoinType.FullJoin)
{
joinQueryResult.ResultModel.SetNullChecking(nullChecking);
foreach (IObjectModel item in modelList)
{
item.SetNullChecking(nullChecking);
}
}
queryModel.FromTable.JoinTables.Add(joinQueryResult.JoinTable);
modelList.Add(joinQueryResult.ResultModel);
}
ScopeParameterDictionary scopeParameters1 = queryModel.ScopeParameters.Clone(queryModel.ScopeParameters.Count + modelList.Count);
for (int i = 0; i < modelList.Count; i++)
{
ParameterExpression p = exp.Selector.Parameters[i];
scopeParameters1[p] = modelList[i];
}
IObjectModel model = SelectorResolver.Resolve(exp.Selector, scopeParameters1, queryModel.ScopeTables);
queryModel.ResultModel = model;
GeneralQueryState queryState = new GeneralQueryState(queryModel);
return(queryState);
}
public GroupKeySelectorParser(ScopeParameterDictionary scopeParameters, StringSet scopeTables)
{
this._scopeParameters = scopeParameters;
this._scopeTables = scopeTables;
}
public static DbExpression[] Parse(Expression keySelector, ScopeParameterDictionary scopeParameters, StringSet scopeTables)
{
return(new GroupKeySelectorParser(scopeParameters, scopeTables).Visit(keySelector));
}
public static DbExpression Parse(Expression exp, ScopeParameterDictionary scopeParameters, StringSet scopeTables)
{
GeneralExpressionParser visitor = new GeneralExpressionParser(scopeParameters, scopeTables);
return(visitor.Visit(exp));
}
