public DbColumnAccessExpression GetColumnAccessExpression(MemberInfo member)
{
DbColumnAccessExpression dbColumnAccessExpression = this.FindColumnAccessExpression(member);
if (dbColumnAccessExpression == null)
{
throw new ChloeException(string.Format("The member '{0}' does not map any column.", member.Name));
}
return(dbColumnAccessExpression);
}
public static DbColumnAccessExpression ParseColumnAccessExpression(DbSqlQueryExpression sqlQuery, DbTable table, DbExpression exp, string defaultAlias = UtilConstants.DefaultColumnAlias)
{
string alias = Utils.GenerateUniqueColumnAlias(sqlQuery, defaultAlias);
DbColumnSegment columnSeg = new DbColumnSegment(exp, alias);
sqlQuery.ColumnSegments.Add(columnSeg);
DbColumnAccessExpression cae = new DbColumnAccessExpression(table, DbColumn.MakeColumn(exp, alias));
return(cae);
}
public virtual GeneralQueryState AsSubQueryState()
{
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
ResultElement result = new ResultElement(this._resultElement.ScopeParameters, this._resultElement.ScopeTables);
DbTableSegment tableSeg = new DbTableSegment(subQuery, result.GenerateUniqueTableAlias());
DbFromTableExpression fromTable = new DbFromTableExpression(tableSeg);
result.FromTable = fromTable;
DbTable table = new DbTable(tableSeg.Alias);
//TODO 根据旧的生成新 MappingMembers
IMappingObjectExpression newMoe = this.Result.MappingObjectExpression.ToNewObjectExpression(sqlQuery, table);
result.MappingObjectExpression = newMoe;
//得将 subQuery.SqlQuery.Orders 告诉 以下创建的 result
//将 orderPart 传递下去
if (this.Result.Orderings.Count > 0)
{
for (int i = 0; i < this.Result.Orderings.Count; i++)
{
DbOrdering ordering = this.Result.Orderings[i];
DbExpression orderingExp = ordering.Expression;
string alias = null;
DbColumnSegment columnExpression = sqlQuery.ColumnSegments.Where(a => DbExpressionEqualityComparer.EqualsCompare(orderingExp, a.Body)).FirstOrDefault();
// 对于重复的则不需要往 sqlQuery.Columns 重复添加了
if (columnExpression != null)
{
alias = columnExpression.Alias;
}
else
{
alias = Utils.GenerateUniqueColumnAlias(sqlQuery);
DbColumnSegment columnSeg = new DbColumnSegment(orderingExp, alias);
sqlQuery.ColumnSegments.Add(columnSeg);
}
DbColumnAccessExpression columnAccessExpression = new DbColumnAccessExpression(table, DbColumn.MakeColumn(orderingExp, alias));
result.Orderings.Add(new DbOrdering(columnAccessExpression, ordering.OrderType));
}
}
result.InheritOrderings = true;
GeneralQueryState queryState = new GeneralQueryState(result);
return queryState;
}
public IMappingObjectExpression ToNewObjectExpression(DbSqlQueryExpression sqlQuery, DbTable table)
{
DbColumnAccessExpression cae = null;
cae = MappingObjectExpressionHelper.ParseColumnAccessExpression(sqlQuery, table, this._exp);
MappingFieldExpression mf = new MappingFieldExpression(this._type, cae);
mf.NullChecking = MappingObjectExpressionHelper.TryGetOrAddNullChecking(sqlQuery, table, this.NullChecking);
return(mf);
}
public override IObjectModel ToNewObjectModel(DbSqlQueryExpression sqlQuery, DbTable table, DbMainTableExpression dependentTable)
{
DbColumnAccessExpression cae = null;
cae = ObjectModelHelper.ParseColumnAccessExpression(sqlQuery, table, this.Expression);
PrimitiveObjectModel objectModel = new PrimitiveObjectModel(this.ObjectType, cae);
objectModel.NullChecking = ObjectModelHelper.TryGetOrAddNullChecking(sqlQuery, table, this.NullChecking);
return(objectModel);
}
public virtual GeneralQueryState AsSubQueryState()
{
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
QueryModel newQueryModel = new QueryModel(this._queryModel.ScopeParameters, this._queryModel.ScopeTables, this._queryModel.IgnoreFilters);
DbTableSegment tableSeg = new DbTableSegment(subQuery, newQueryModel.GenerateUniqueTableAlias(), LockType.Unspecified);
DbFromTableExpression fromTable = new DbFromTableExpression(tableSeg);
newQueryModel.FromTable = fromTable;
DbTable aliasTable = new DbTable(tableSeg.Alias);
//TODO 根据旧的生成新 ResultModel
IObjectModel newResultModel = this.QueryModel.ResultModel.ToNewObjectModel(sqlQuery, aliasTable, fromTable);
newQueryModel.ResultModel = newResultModel;
//得将 subQuery.SqlQuery.Orders 告诉 以下创建的 result
//将 orderPart 传递下去
for (int i = 0; i < this.QueryModel.Orderings.Count; i++)
{
DbOrdering ordering = this.QueryModel.Orderings[i];
DbExpression orderingExp = ordering.Expression;
string alias = null;
DbColumnSegment columnExpression = sqlQuery.ColumnSegments.Find(a => DbExpressionEqualityComparer.EqualsCompare(orderingExp, a.Body));
// 对于重复的则不需要往 sqlQuery.Columns 重复添加了
if (columnExpression != null)
{
alias = columnExpression.Alias;
}
else
{
alias = Utils.GenerateUniqueColumnAlias(sqlQuery);
DbColumnSegment columnSeg = new DbColumnSegment(orderingExp, alias);
sqlQuery.ColumnSegments.Add(columnSeg);
}
DbColumnAccessExpression columnAccessExpression = new DbColumnAccessExpression(aliasTable, DbColumn.MakeColumn(orderingExp, alias));
newQueryModel.Orderings.Add(new DbOrdering(columnAccessExpression, ordering.OrderType));
}
newQueryModel.InheritOrderings = true;
GeneralQueryState queryState = new GeneralQueryState(newQueryModel);
return(queryState);
}
static ResultElement CreateResultElement(Type type, string explicitTableName)
{
if (type.IsAbstract || type.IsInterface)
{
throw new ArgumentException("The type of input can not be abstract class or interface.");
}
//TODO init _resultElement
ResultElement resultElement = new ResultElement();
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(type);
DbTable dbTable = typeDescriptor.Table;
if (explicitTableName != null)
{
dbTable = new DbTable(explicitTableName, dbTable.Schema);
}
string alias = resultElement.GenerateUniqueTableAlias(dbTable.Name);
resultElement.FromTable = CreateRootTable(dbTable, alias);
ConstructorInfo constructor = typeDescriptor.EntityType.GetConstructor(Type.EmptyTypes);
if (constructor == null)
{
throw new ArgumentException(string.Format("The type of '{0}' does't define a none parameter constructor.", type.FullName));
}
MappingObjectExpression moe = new MappingObjectExpression(constructor);
DbTableSegment tableExp = resultElement.FromTable.Table;
DbTable table = new DbTable(alias);
foreach (MappingMemberDescriptor item in typeDescriptor.MappingMemberDescriptors.Values)
{
DbColumnAccessExpression columnAccessExpression = new DbColumnAccessExpression(table, item.Column);
moe.AddMappingMemberExpression(item.MemberInfo, columnAccessExpression);
if (item.IsPrimaryKey)
{
moe.PrimaryKey = columnAccessExpression;
}
}
resultElement.MappingObjectExpression = moe;
return(resultElement);
}
protected override DbExpression VisitMemberAccess(MemberExpression exp)
{
if (ExpressionExtension.IsDerivedFromParameter(exp))
{
Stack <MemberExpression> reversedExps = ExpressionExtension.Reverse(exp);
DbExpression dbExp = null;
bool first = true;
foreach (var me in reversedExps)
{
if (first)
{
DbColumnAccessExpression dbColumnAccessExpression = this._typeDescriptor.TryGetColumnAccessExpression(me.Member);
if (this._explicitDbTable != null)
{
dbColumnAccessExpression = new DbColumnAccessExpression(this._explicitDbTable, dbColumnAccessExpression.Column);
}
if (dbColumnAccessExpression == null)
{
throw new SZORMException(string.Format("The member '{0}' does not map any column.", me.Member.Name));
}
dbExp = dbColumnAccessExpression;
first = false;
}
else
{
DbMemberExpression dbMe = new DbMemberExpression(me.Member, dbExp);
dbExp = dbMe;
}
}
if (dbExp != null)
{
return(dbExp);
}
else
{
throw new Exception();
}
}
else
{
return(base.VisitMemberAccess(exp));
}
}
public override JoinQueryResult Visit(RootQueryExpression exp)
{
Type type = exp.ElementType;
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(type);
string explicitTableName = exp.ExplicitTable;
DbTable dbTable = typeDescriptor.Table;
if (explicitTableName != null)
{
dbTable = new DbTable(explicitTableName, dbTable.Schema);
}
string alias = this._resultElement.GenerateUniqueTableAlias(dbTable.Name);
DbTableSegment tableSeg = CreateTableExpression(dbTable, alias);
MappingObjectExpression moe = new MappingObjectExpression(typeDescriptor.EntityType.GetConstructor(Type.EmptyTypes));
DbTable table = new DbTable(alias);
foreach (MappingMemberDescriptor item in typeDescriptor.MappingMemberDescriptors.Values)
{
DbColumnAccessExpression columnAccessExpression = new DbColumnAccessExpression(table, item.Column);
moe.AddMemberExpression(item.MemberInfo, columnAccessExpression);
if (item.IsPrimaryKey)
{
moe.PrimaryKey = columnAccessExpression;
}
}
//TODO 解析 on 条件表达式
DbExpression condition = null;
List <IMappingObjectExpression> moeList = new List <IMappingObjectExpression>(this._moeList.Count + 1);
moeList.AddRange(this._moeList);
moeList.Add(moe);
condition = GeneralExpressionVisitor.ParseLambda(this._conditionExpression, moeList);
DbJoinTableExpression joinTable = new DbJoinTableExpression(this._joinType, tableSeg, condition);
JoinQueryResult result = new JoinQueryResult();
result.MappingObjectExpression = moe;
result.JoinTable = joinTable;
return(result);
}
public static DbExpression MakeCondition(PairList <PrimitivePropertyDescriptor, object> propertyValuePairs, DbTable dbTable)
{
DbExpression conditionExp = null;
foreach (var pair in propertyValuePairs)
{
PrimitivePropertyDescriptor propertyDescriptor = pair.Item1;
object val = pair.Item2;
DbExpression left = new DbColumnAccessExpression(dbTable, propertyDescriptor.Column);
DbExpression right = DbExpression.Parameter(val, propertyDescriptor.PropertyType, propertyDescriptor.Column.DbType);
DbExpression equalExp = new DbEqualExpression(left, right);
conditionExp = conditionExp.And(equalExp);
}
return(conditionExp);
}
internal ComplexObjectModel GenObjectModel(DbTable table)
{
ComplexObjectModel model = new ComplexObjectModel(this.Definition.Type);
foreach (PrimitivePropertyDescriptor propertyDescriptor in this.PrimitivePropertyDescriptors)
{
DbColumnAccessExpression columnAccessExpression = new DbColumnAccessExpression(table, propertyDescriptor.Column);
model.AddPrimitiveMember(propertyDescriptor.Property, columnAccessExpression);
if (propertyDescriptor.IsPrimaryKey)
{
model.PrimaryKey = columnAccessExpression;
}
}
return(model);
}
public override JoinQueryResult Visit(RootQueryExpression exp)
{
Type type = exp.ElementType;
TypeDescriptor typeDescriptor = EntityTypeContainer.GetDescriptor(type);
string explicitTableName = exp.ExplicitTable;
DbTable dbTable = typeDescriptor.Table;
if (explicitTableName != null)
{
dbTable = new DbTable(explicitTableName, dbTable.Schema);
}
string alias = this._resultElement.GenerateUniqueTableAlias(dbTable.Name);
DbTableSegment tableSeg = CreateTableSegment(dbTable, alias, exp.Lock);
MappingObjectExpression moe = new MappingObjectExpression(typeDescriptor.Definition.Type.GetConstructor(Type.EmptyTypes));
DbTable table = new DbTable(alias);
foreach (PropertyDescriptor item in typeDescriptor.PropertyDescriptors)
{
DbColumnAccessExpression columnAccessExpression = new DbColumnAccessExpression(table, item.Column);
moe.AddMappingMemberExpression(item.Property, columnAccessExpression);
if (item.IsPrimaryKey)
{
moe.PrimaryKey = columnAccessExpression;
}
}
//TODO 解析 on 条件表达式
var scopeParameters = this._scopeParameters.Clone(this._conditionExpression.Parameters.Last(), moe);
DbExpression condition = GeneralExpressionParser.Parse(this._conditionExpression, scopeParameters, this._resultElement.ScopeTables);
DbJoinTableExpression joinTable = new DbJoinTableExpression(this._joinType.AsDbJoinType(), tableSeg, condition);
JoinQueryResult result = new JoinQueryResult();
result.MappingObjectExpression = moe;
result.JoinTable = joinTable;
return(result);
}
public override DbExpression Visit(DbSqlQueryExpression exp)
{
if (exp.TakeCount != null)
{
DbSqlQueryExpression newSqlQuery = CloneWithoutLimitInfo(exp, "TTAKE");
if (exp.SkipCount == null)
{
AppendLimitCondition(newSqlQuery, exp.TakeCount.Value);
}
else
{
AppendLimitCondition(newSqlQuery, exp.TakeCount.Value + exp.SkipCount.Value);
newSqlQuery.SkipCount = exp.SkipCount.Value;
}
newSqlQuery.IsDistinct = exp.IsDistinct;
newSqlQuery.Accept(this);
return(exp);
}
else if (exp.SkipCount != null)
{
DbSqlQueryExpression subSqlQuery = CloneWithoutLimitInfo(exp, "TSKIP");
string row_numberName = GenRowNumberName(subSqlQuery.ColumnSegments);
DbColumnSegment row_numberSeg = new DbColumnSegment(OracleSemantics.DbMemberExpression_ROWNUM, row_numberName);
subSqlQuery.ColumnSegments.Add(row_numberSeg);
DbTable table = new DbTable("T");
DbSqlQueryExpression newSqlQuery = WrapSqlQuery(subSqlQuery, table, exp.ColumnSegments);
DbColumnAccessExpression columnAccessExp = new DbColumnAccessExpression(table, DbColumn.MakeColumn(row_numberSeg.Body, row_numberName));
newSqlQuery.Condition = DbExpression.GreaterThan(columnAccessExp, DbExpression.Constant(exp.SkipCount.Value));
newSqlQuery.IsDistinct = exp.IsDistinct;
newSqlQuery.Accept(this);
return(exp);
}
this.BuildGeneralSql(exp);
return(exp);
}
static DbExpression MakeCondition(Dictionary <PropertyDescriptor, object> keyValueMap, DbTable dbTable)
{
DbExpression conditionExp = null;
foreach (var kv in keyValueMap)
{
PropertyDescriptor keyPropertyDescriptor = kv.Key;
object keyVal = kv.Value;
if (keyVal == null)
{
throw new ArgumentException(string.Format("The primary key '{0}' could not be null.", keyPropertyDescriptor.Property.Name));
}
DbExpression left = new DbColumnAccessExpression(dbTable, keyPropertyDescriptor.Column);
DbExpression right = DbExpression.Parameter(keyVal, keyPropertyDescriptor.PropertyType, keyPropertyDescriptor.Column.DbType);
DbExpression equalExp = new DbEqualExpression(left, right);
conditionExp = conditionExp == null ? equalExp : DbExpression.And(conditionExp, equalExp);
}
return(conditionExp);
}
public static DbExpression TryGetOrAddNullChecking(DbSqlQueryExpression sqlQuery, DbTable table, DbExpression exp)
{
if (exp == null)
{
return(null);
}
List <DbColumnSegment> columnList = sqlQuery.ColumnSegments;
DbColumnSegment columnSeg = null;
columnSeg = columnList.Where(a => DbExpressionEqualityComparer.EqualsCompare(a.Body, exp)).FirstOrDefault();
if (columnSeg == null)
{
string alias = Utils.GenerateUniqueColumnAlias(sqlQuery);
columnSeg = new DbColumnSegment(exp, alias);
columnList.Add(columnSeg);
}
DbColumnAccessExpression cae = new DbColumnAccessExpression(columnSeg.Body.Type, table, columnSeg.Alias);
return(cae);
}
public override int Update <TEntity>(TEntity entity, string table)
{
Utils.CheckNull(entity);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
EnsureMappingTypeHasPrimaryKey(typeDescriptor);
MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKey;
MemberInfo keyMember = keyMemberDescriptor.MemberInfo;
object keyVal = null;
IEntityState entityState = this.TryGetTrackedEntityState(entity);
Dictionary <MappingMemberDescriptor, DbExpression> updateColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
MemberInfo member = kv.Key;
MappingMemberDescriptor memberDescriptor = kv.Value;
if (member == keyMember)
{
keyVal = memberDescriptor.GetValue(entity);
keyMemberDescriptor = memberDescriptor;
continue;
}
SequenceAttribute attr = (SequenceAttribute)memberDescriptor.GetCustomAttribute(typeof(SequenceAttribute));
if (attr != null)
{
continue;
}
object val = memberDescriptor.GetValue(entity);
if (entityState != null && !entityState.HasChanged(memberDescriptor, val))
{
continue;
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
updateColumns.Add(memberDescriptor, valExp);
}
if (keyVal == null)
{
throw new ChloeException(string.Format("The primary key '{0}' could not be null.", keyMember.Name));
}
if (updateColumns.Count == 0)
{
return(0);
}
DbTable dbTable = table == null ? typeDescriptor.Table : new DbTable(table, typeDescriptor.Table.Schema);
DbExpression left = new DbColumnAccessExpression(dbTable, keyMemberDescriptor.Column);
DbExpression right = DbExpression.Parameter(keyVal, keyMemberDescriptor.MemberInfoType);
DbExpression conditionExp = new DbEqualExpression(left, right);
DbUpdateExpression e = new DbUpdateExpression(dbTable, conditionExp);
foreach (var item in updateColumns)
{
e.UpdateColumns.Add(item.Key.Column, item.Value);
}
int ret = this.ExecuteSqlCommand(e);
if (entityState != null)
{
entityState.Refresh();
}
return(ret);
}
public IObjectModel ToNewObjectModel(DbSqlQueryExpression sqlQuery, DbTable table, DbMainTableExpression dependentTable)
{
ComplexObjectModel newModel = new ComplexObjectModel(this.ConstructorDescriptor);
newModel.DependentTable = dependentTable;
newModel.IncludeCollections.AddRange(this.IncludeCollections);
foreach (var kv in this.PrimitiveConstructorParameters)
{
ParameterInfo pi = kv.Key;
DbExpression exp = kv.Value;
DbColumnAccessExpression cae = null;
cae = ObjectModelHelper.ParseColumnAccessExpression(sqlQuery, table, exp, pi.Name);
newModel.AddConstructorParameter(pi, cae);
}
foreach (var kv in this.ComplexConstructorParameters)
{
ParameterInfo pi = kv.Key;
IObjectModel val = kv.Value;
ComplexObjectModel complexMemberModel = val.ToNewObjectModel(sqlQuery, table, dependentTable) as ComplexObjectModel;
newModel.AddConstructorParameter(pi, complexMemberModel);
}
foreach (var kv in this.PrimitiveMembers)
{
MemberInfo member = kv.Key;
DbExpression exp = kv.Value;
DbColumnAccessExpression cae = ObjectModelHelper.ParseColumnAccessExpression(sqlQuery, table, exp, member.Name);
newModel.AddPrimitiveMember(member, cae);
if (exp == this.PrimaryKey)
{
newModel.PrimaryKey = cae;
if (this.NullChecking == this.PrimaryKey)
{
newModel.NullChecking = cae;
}
}
}
foreach (var kv in this.ComplexMembers)
{
MemberInfo member = kv.Key;
IObjectModel val = kv.Value;
ComplexObjectModel complexMemberModel = val.ToNewObjectModel(sqlQuery, table, dependentTable) as ComplexObjectModel;
newModel.AddComplexMember(member, complexMemberModel);
}
if (newModel.NullChecking == null)
{
newModel.NullChecking = ObjectModelHelper.TryGetOrAddNullChecking(sqlQuery, table, this.NullChecking);
}
return(newModel);
}
public override DbExpression Visit(DbColumnAccessExpression exp)
{
return(exp);
}
public static bool ExpressionEquals(DbColumnAccessExpression exp1, DbColumnAccessExpression exp2)
{
if (exp1.Column.Name != exp2.Column.Name)
return false;
return exp1.Table.Name == exp2.Table.Name;
}
public override DbExpression Visit(DbColumnAccessExpression exp)
{
return(exp.Accept(this._generator));
}
public abstract T Visit(DbColumnAccessExpression exp);
public override int Update <T>(T entity)
{
Utils.CheckNull(entity);
TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entity.GetType());
EnsureMappingTypeHasPrimaryKey(typeDescriptor);
object keyVal = null;
MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKey;
MemberInfo keyMember = keyMemberDescriptor.MemberInfo;
IEntityState entityState = this.TryGetTrackedEntityState(entity);
Dictionary <MappingMemberDescriptor, DbExpression> updateColumns = new Dictionary <MappingMemberDescriptor, DbExpression>();
foreach (var kv in typeDescriptor.MappingMemberDescriptors)
{
var member = kv.Key;
var memberDescriptor = kv.Value;
if (member == keyMember)
{
keyVal = memberDescriptor.GetValue(entity);
keyMemberDescriptor = memberDescriptor;
continue;
}
AutoIncrementAttribute attr = (AutoIncrementAttribute)memberDescriptor.GetCustomAttribute(typeof(AutoIncrementAttribute));
if (attr != null)
{
continue;
}
var val = memberDescriptor.GetValue(entity);
if (entityState != null && !entityState.IsChanged(member, val))
{
continue;
}
DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
updateColumns.Add(memberDescriptor, valExp);
}
if (keyVal == null)
{
throw new Exception(string.Format("实体主键 {0} 值为 null", keyMember.Name));
}
if (updateColumns.Count == 0)
{
return(0);
}
DbExpression left = new DbColumnAccessExpression(typeDescriptor.Table, keyMemberDescriptor.Column);
DbExpression right = DbExpression.Parameter(keyVal, keyMemberDescriptor.MemberInfoType);
DbExpression conditionExp = new DbEqualExpression(left, right);
DbUpdateExpression e = new DbUpdateExpression(typeDescriptor.Table, conditionExp);
foreach (var item in updateColumns)
{
e.UpdateColumns.Add(item.Key.Column, item.Value);
}
int ret = this.ExecuteSqlCommand(e);
if (entityState != null)
{
entityState.Refresh();
}
return(ret);
}
public virtual GeneralQueryState AsSubQueryState()
{
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
ResultElement result = new ResultElement();
DbTableSegment tableSeg = new DbTableSegment(subQuery, result.GenerateUniqueTableAlias());
DbFromTableExpression fromTable = new DbFromTableExpression(tableSeg);
result.FromTable = fromTable;
DbTable table = new DbTable(tableSeg.Alias);
//TODO 根据旧的生成新 MappingMembers
IMappingObjectExpression newMoe = this.Result.MappingObjectExpression.ToNewObjectExpression(sqlQuery, table);
result.MappingObjectExpression = newMoe;
//得将 subQuery.SqlQuery.Orders 告诉 以下创建的 result
//将 orderPart 传递下去
if (this.Result.OrderSegments.Count > 0)
{
for (int i = 0; i < this.Result.OrderSegments.Count; i++)
{
DbOrderSegment orderPart = this.Result.OrderSegments[i];
DbExpression orderExp = orderPart.DbExpression;
string alias = null;
DbColumnSegment columnExpression = sqlQuery.ColumnSegments.Where(a => DbExpressionEqualityComparer.EqualsCompare(orderExp, a.Body)).FirstOrDefault();
// 对于重复的则不需要往 sqlQuery.Columns 重复添加了
if (columnExpression != null)
{
alias = columnExpression.Alias;
}
else
{
alias = Utils.GenerateUniqueColumnAlias(sqlQuery);
DbColumnSegment columnSeg = new DbColumnSegment(orderExp, alias);
sqlQuery.ColumnSegments.Add(columnSeg);
}
DbColumnAccessExpression columnAccessExpression = new DbColumnAccessExpression(orderExp.Type, table, alias);
result.OrderSegments.Add(new DbOrderSegment(columnAccessExpression, orderPart.OrderType));
}
}
result.IsOrderSegmentsFromSubQuery = true;
GeneralQueryState queryState = new GeneralQueryState(result);
return queryState;
}
public IMappingObjectExpression ToNewObjectExpression(DbSqlQueryExpression sqlQuery, DbTable table)
{
List <DbColumnSegment> columnList = sqlQuery.ColumnSegments;
MappingObjectExpression moe = new MappingObjectExpression(this.ConstructorDescriptor);
MappingObjectExpression mappingMembers = this;
foreach (var kv in this.ConstructorParameters)
{
ParameterInfo pi = kv.Key;
DbExpression exp = kv.Value;
DbColumnAccessExpression cae = null;
cae = MappingObjectExpressionHelper.ParseColumnAccessExpression(sqlQuery, table, exp, pi.Name);
moe.AddConstructorParameter(pi, cae);
}
foreach (var kv in mappingMembers.ConstructorEntityParameters)
{
ParameterInfo pi = kv.Key;
IMappingObjectExpression val = kv.Value;
IMappingObjectExpression navMappingMember = val.ToNewObjectExpression(sqlQuery, table);
moe.AddConstructorEntityParameter(pi, navMappingMember);
}
foreach (var kv in mappingMembers.SelectedMembers)
{
MemberInfo member = kv.Key;
DbExpression exp = kv.Value;
DbColumnAccessExpression cae = null;
cae = MappingObjectExpressionHelper.ParseColumnAccessExpression(sqlQuery, table, exp, member.Name);
moe.AddMemberExpression(member, cae);
if (exp == this.PrimaryKey)
{
moe.PrimaryKey = cae;
if (this.NullChecking == this.PrimaryKey)
{
moe.NullChecking = cae;
}
}
}
foreach (var kv in mappingMembers.SubResultEntities)
{
MemberInfo member = kv.Key;
IMappingObjectExpression val = kv.Value;
IMappingObjectExpression navMappingMember = val.ToNewObjectExpression(sqlQuery, table);
moe.AddNavMemberExpression(member, navMappingMember);
}
if (moe.NullChecking == null)
{
moe.NullChecking = MappingObjectExpressionHelper.TryGetOrAddNullChecking(sqlQuery, table, this.NullChecking);
}
return(moe);
}
