public static string GenerateUniqueColumnAlias(DbSqlQueryExpression sqlQuery, string defaultAlias = UtilConstants.DefaultColumnAlias)
{
string alias = defaultAlias;
int i = 0;
while (sqlQuery.ColumnSegments.Any(a => string.Equals(a.Alias, alias, StringComparison.OrdinalIgnoreCase)))
{
alias = defaultAlias + i.ToString();
i++;
}
return(alias);
}
public virtual DbSqlQueryExpression CreateSqlQuery()
{
DbSqlQueryExpression sqlQuery = new DbSqlQueryExpression();
sqlQuery.Table = this._resultElement.FromTable;
sqlQuery.OrderSegments.AddRange(this._resultElement.OrderSegments);
sqlQuery.Condition = this._resultElement.Condition;
sqlQuery.GroupSegments.AddRange(this._resultElement.GroupSegments);
sqlQuery.HavingCondition = this._resultElement.HavingCondition;
return(sqlQuery);
}
public virtual MappingData GenerateMappingData()
{
MappingData data = new MappingData();
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
var moe = this._resultElement.MappingObjectExpression.GenarateObjectActivatorCreator(sqlQuery);
data.SqlQuery = sqlQuery;
data.MappingEntity = moe;
return(data);
}
static DbSqlQueryExpression WrapSqlQuery(DbSqlQueryExpression sqlQuery, DbTable table, List <DbColumnSegment> columnSegments = null)
{
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
DbSqlQueryExpression newSqlQuery = new DbSqlQueryExpression();
DbTableSegment tableSeg = new DbTableSegment(subQuery, table.Name, LockType.Unspecified);
DbFromTableExpression fromTableExp = new DbFromTableExpression(tableSeg);
newSqlQuery.Table = fromTableExp;
CopyColumnSegments(columnSegments ?? subQuery.SqlQuery.ColumnSegments, newSqlQuery.ColumnSegments, table);
return(newSqlQuery);
}
DbSqlQueryExpression ConvertToDbSqlQueryExpression(Expression exp, Type resultType)
{
if (!IsIQueryType(exp.Type))
{
throw new NotSupportedException(exp.ToString());
}
QueryBase query = ExpressionEvaluator.Evaluate(exp) as QueryBase;
IQueryState qs = QueryExpressionVisitor.VisitQueryExpression(query.QueryExpression, this._scopeParameters, this._scopeTables);
MappingData mappingData = qs.GenerateMappingData();
DbSqlQueryExpression sqlQueryExpression = mappingData.SqlQuery.Update(resultType);
return(sqlQueryExpression);
}
void BuildGeneralSql(DbSqlQueryExpression exp)
{
if (exp.TakeCount != null || exp.SkipCount != null)
{
throw new ArgumentException();
}
this.SqlBuilder.Append("SELECT ");
if (exp.IsDistinct)
{
this.SqlBuilder.Append("DISTINCT ");
}
List <DbColumnSegment> columns = exp.ColumnSegments;
for (int i = 0; i < columns.Count; i++)
{
DbColumnSegment column = columns[i];
if (i > 0)
{
this.SqlBuilder.Append(",");
}
this.AppendColumnSegment(column);
}
this.SqlBuilder.Append(" FROM ");
exp.Table.Accept(this);
this.BuildWhereState(exp.Condition);
this.BuildGroupState(exp);
this.BuildOrderState(exp.Orderings);
DbTableSegment seg = exp.Table.Table;
if (seg.Lock == LockType.UpdLock)
{
this.SqlBuilder.Append(" FOR UPDATE");
}
else if (seg.Lock == LockType.Unspecified || seg.Lock == LockType.NoLock)
{
//Do nothing.
}
else
{
throw new NotSupportedException($"lock type: {seg.Lock.ToString()}");
}
}
public override DbExpression Visit(DbSqlQueryExpression exp)
{
if (exp.SkipCount != null)
{
this.BuildLimitSql(exp);
return(exp);
}
else
{
//构建常规的查询
this.BuildGeneralSql(exp);
return(exp);
}
throw new NotImplementedException();
}
public virtual FromQueryResult ToFromQueryResult()
{
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
DbTableSegment tableSeg = new DbTableSegment(subQuery, UtilConstants.DefaultTableAlias);
DbFromTableExpression fromTable = new DbFromTableExpression(tableSeg);
DbTable table = new DbTable(tableSeg.Alias);
IMappingObjectExpression newMoe = this.Result.MappingObjectExpression.ToNewObjectExpression(sqlQuery, table);
FromQueryResult result = new FromQueryResult();
result.FromTable = fromTable;
result.MappingObjectExpression = newMoe;
return(result);
}
public virtual QueryModel ToFromQueryModel()
{
QueryModel queryModel = new QueryModel(this._queryModel.ScopeParameters, this._queryModel.ScopeTables, this._queryModel.IgnoreFilters);
string alias = queryModel.GenerateUniqueTableAlias(UtilConstants.DefaultTableAlias);
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
DbTableSegment tableSeg = new DbTableSegment(subQuery, alias, LockType.Unspecified);
DbFromTableExpression fromTable = new DbFromTableExpression(tableSeg);
DbTable aliasTable = new DbTable(tableSeg.Alias);
IObjectModel newModel = this.QueryModel.ResultModel.ToNewObjectModel(sqlQuery, aliasTable, fromTable);
queryModel.FromTable = fromTable;
queryModel.ResultModel = newModel;
return(queryModel);
}
public virtual ResultElement ToFromQueryResult()
{
ResultElement result = new ResultElement(this._resultElement.ScopeParameters, this._resultElement.ScopeTables);
string alias = result.GenerateUniqueTableAlias(UtilConstants.DefaultTableAlias);
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
DbTableSegment tableSeg = new DbTableSegment(subQuery, alias, LockType.Unspecified);
DbFromTableExpression fromTable = new DbFromTableExpression(tableSeg);
DbTable table = new DbTable(tableSeg.Alias);
IMappingObjectExpression newMoe = this.Result.MappingObjectExpression.ToNewObjectExpression(sqlQuery, table);
result.FromTable = fromTable;
result.MappingObjectExpression = newMoe;
return(result);
}
public DbSqlQueryExpression CreateSqlQuery()
{
DbSqlQueryExpression sqlQuery = new DbSqlQueryExpression();
sqlQuery.Table = this.FromTable;
sqlQuery.Orderings.AddRange(this.Orderings);
sqlQuery.Condition = this.Condition;
if (!this.IgnoreFilters)
{
sqlQuery.Condition = this.ContextFilters.And().And(sqlQuery.Condition).And(this.GlobalFilters);
}
sqlQuery.GroupSegments.AddRange(this.GroupSegments);
sqlQuery.HavingCondition = this.HavingCondition;
return(sqlQuery);
}
void BuildGeneralSql(DbSqlQueryExpression exp)
{
this.SqlBuilder.Append("SELECT ");
if (exp.IsDistinct)
{
this.SqlBuilder.Append("DISTINCT ");
}
List <DbColumnSegment> columns = exp.ColumnSegments;
for (int i = 0; i < columns.Count; i++)
{
DbColumnSegment column = columns[i];
if (i > 0)
{
this.SqlBuilder.Append(",");
}
this.AppendColumnSegment(column);
}
this.SqlBuilder.Append(" FROM ");
exp.Table.Accept(this);
this.BuildWhereState(exp.Condition);
this.BuildGroupState(exp);
this.BuildOrderState(exp.Orderings);
if (exp.SkipCount == null && exp.TakeCount == null)
{
return;
}
int skipCount = exp.SkipCount ?? 0;
long takeCount = long.MaxValue;
if (exp.TakeCount != null)
{
takeCount = exp.TakeCount.Value;
}
this.SqlBuilder.Append(" LIMIT ", takeCount.ToString(), " OFFSET ", skipCount.ToString());
}
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 DbSqlQueryExpression CloneWithoutLimitInfo(DbSqlQueryExpression sqlQuery, string wraperTableName = "T")
{
DbSqlQueryExpression newSqlQuery = new DbSqlQueryExpression();
newSqlQuery.Table = sqlQuery.Table;
newSqlQuery.ColumnSegments.AddRange(sqlQuery.ColumnSegments);
newSqlQuery.Condition = sqlQuery.Condition;
newSqlQuery.GroupSegments.AddRange(sqlQuery.GroupSegments);
newSqlQuery.HavingCondition = sqlQuery.HavingCondition;
newSqlQuery.Orderings.AddRange(sqlQuery.Orderings);
if (sqlQuery.Orderings.Count > 0 || sqlQuery.GroupSegments.Count > 0)
{
newSqlQuery = WrapSqlQuery(newSqlQuery, new DbTable(wraperTableName));
}
return(newSqlQuery);
}
void BuildGroupState(DbSqlQueryExpression exp)
{
var groupSegments = exp.GroupSegments;
if (groupSegments.Count == 0)
return;
this._sqlBuilder.Append(" GROUP BY ");
for (int i = 0; i < groupSegments.Count; i++)
{
if (i > 0)
this._sqlBuilder.Append(",");
groupSegments[i].Accept(this);
}
if (exp.HavingCondition != null)
{
this._sqlBuilder.Append(" HAVING ");
exp.HavingCondition.Accept(this);
}
}
public override DbExpression Visit(DbExistsExpression exp)
{
this._sqlBuilder.Append("Exists ");
DbSqlQueryExpression rawSqlQuery = exp.SqlQuery;
DbSqlQueryExpression sqlQuery = new DbSqlQueryExpression()
{
TakeCount = rawSqlQuery.TakeCount,
SkipCount = rawSqlQuery.SkipCount,
Table = rawSqlQuery.Table,
Condition = rawSqlQuery.Condition,
HavingCondition = rawSqlQuery.HavingCondition,
};
sqlQuery.GroupSegments.AddRange(rawSqlQuery.GroupSegments);
DbColumnSegment columnSegment = new DbColumnSegment(DbExpression.Constant("1"), "C");
sqlQuery.ColumnSegments.Add(columnSegment);
DbSubQueryExpression subQuery = new DbSubQueryExpression(sqlQuery);
return subQuery.Accept(this);
}
public virtual MappingData GenerateMappingData()
{
MappingData data = new MappingData();
ComplexObjectModel complexObjectModel = this._queryModel.ResultModel as ComplexObjectModel;
if (complexObjectModel != null)
{
complexObjectModel.SetupCollection(this._queryModel);
}
DbSqlQueryExpression sqlQuery = this.CreateSqlQuery();
var objectActivatorCreator = this._queryModel.ResultModel.GenarateObjectActivatorCreator(sqlQuery);
objectActivatorCreator.IsRoot = true;
data.SqlQuery = sqlQuery;
data.ObjectActivatorCreator = objectActivatorCreator;
return(data);
}
public DbSqlQueryExpression CreateSqlQuery()
{
DbSqlQueryExpression sqlQuery = new DbSqlQueryExpression();
sqlQuery.Table = this.FromTable;
sqlQuery.Orderings.AddRange(this.Orderings);
sqlQuery.Condition = this.Condition;
if (!this.IgnoreFilters)
{
for (int i = 0; i < this.Filters.Count; i++)
{
var filter = this.Filters[i];
sqlQuery.Condition = sqlQuery.Condition.And(filter);
}
}
sqlQuery.GroupSegments.AddRange(this.GroupSegments);
sqlQuery.HavingCondition = this.HavingCondition;
return(sqlQuery);
}
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);
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 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 IObjectActivatorCreator GenarateObjectActivatorCreator(DbSqlQueryExpression sqlQuery)
{
MappingEntity mappingEntity = new MappingEntity(this.ConstructorDescriptor);
foreach (var kv in this.MappingConstructorParameters)
{
ParameterInfo pi = kv.Key;
DbExpression exp = kv.Value;
int ordinal;
ordinal = MappingObjectExpressionHelper.TryGetOrAddColumn(sqlQuery, exp, pi.Name).Value;
if (exp == this.NullChecking)
{
mappingEntity.CheckNullOrdinal = ordinal;
}
mappingEntity.ConstructorParameters.Add(pi, ordinal);
}
foreach (var kv in this.ComplexConstructorParameters)
{
ParameterInfo pi = kv.Key;
IMappingObjectExpression val = kv.Value;
IObjectActivatorCreator complexMappingMember = val.GenarateObjectActivatorCreator(sqlQuery);
mappingEntity.ConstructorEntityParameters.Add(pi, complexMappingMember);
}
foreach (var kv in this.MappingMembers)
{
MemberInfo member = kv.Key;
DbExpression exp = kv.Value;
int ordinal;
ordinal = MappingObjectExpressionHelper.TryGetOrAddColumn(sqlQuery, exp, member.Name).Value;
if (exp == this.NullChecking)
{
mappingEntity.CheckNullOrdinal = ordinal;
}
mappingEntity.MappingMembers.Add(member, ordinal);
}
foreach (var kv in this.ComplexMembers)
{
MemberInfo member = kv.Key;
IMappingObjectExpression val = kv.Value;
IObjectActivatorCreator complexMappingMember = val.GenarateObjectActivatorCreator(sqlQuery);
mappingEntity.ComplexMembers.Add(kv.Key, complexMappingMember);
}
if (mappingEntity.CheckNullOrdinal == null)
{
mappingEntity.CheckNullOrdinal = MappingObjectExpressionHelper.TryGetOrAddColumn(sqlQuery, this.NullChecking);
}
return(mappingEntity);
}
public virtual DbSqlQueryExpression CreateSqlQuery()
{
DbSqlQueryExpression sqlQuery = new DbSqlQueryExpression();
sqlQuery.Table = this._resultElement.FromTable;
sqlQuery.OrderSegments.AddRange(this._resultElement.OrderSegments);
sqlQuery.Condition = this._resultElement.Condition;
sqlQuery.GroupSegments.AddRange(this._resultElement.GroupSegments);
sqlQuery.HavingCondition = this._resultElement.HavingCondition;
return sqlQuery;
}
public override DbExpression Visit(DbSqlQueryExpression exp)
{
this.BuildGeneralSql(exp);
return(exp);
}
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);
}
public IObjectActivatorCreator GenarateObjectActivatorCreator(DbSqlQueryExpression sqlQuery)
{
List <DbColumnSegment> columnList = sqlQuery.ColumnSegments;
MappingEntity mappingEntity = new MappingEntity(this.ConstructorDescriptor);
MappingObjectExpression mappingMembers = this;
foreach (var kv in this.ConstructorParameters)
{
ParameterInfo pi = kv.Key;
DbExpression exp = kv.Value;
int ordinal;
ordinal = MappingObjectExpressionHelper.TryGetOrAddColumn(sqlQuery, exp, pi.Name).Value;
if (exp == this.NullChecking)
{
mappingEntity.CheckNullOrdinal = ordinal;
}
mappingEntity.ConstructorParameters.Add(pi, ordinal);
}
foreach (var kv in mappingMembers.ConstructorEntityParameters)
{
ParameterInfo pi = kv.Key;
IMappingObjectExpression val = kv.Value;
IObjectActivatorCreator navMappingMember = val.GenarateObjectActivatorCreator(sqlQuery);
mappingEntity.ConstructorEntityParameters.Add(pi, navMappingMember);
}
foreach (var kv in mappingMembers.SelectedMembers)
{
MemberInfo member = kv.Key;
DbExpression exp = kv.Value;
int ordinal;
ordinal = MappingObjectExpressionHelper.TryGetOrAddColumn(sqlQuery, exp, member.Name).Value;
if (exp == this.NullChecking)
{
mappingEntity.CheckNullOrdinal = ordinal;
}
mappingEntity.Members.Add(member, ordinal);
}
foreach (var kv in mappingMembers.SubResultEntities)
{
MemberInfo member = kv.Key;
IMappingObjectExpression val = kv.Value;
IObjectActivatorCreator navMappingMember = val.GenarateObjectActivatorCreator(sqlQuery);
mappingEntity.EntityMembers.Add(kv.Key, navMappingMember);
}
if (mappingEntity.CheckNullOrdinal == null)
{
mappingEntity.CheckNullOrdinal = MappingObjectExpressionHelper.TryGetOrAddColumn(sqlQuery, this.NullChecking);
}
return(mappingEntity);
}
public override DbExpression Visit(DbSqlQueryExpression exp)
{
return(exp);
}
protected virtual void BuildLimitSql(DbSqlQueryExpression exp)
{
bool shouldSortResults = false;
if (exp.TakeCount != null)
{
shouldSortResults = true;
}
else if (this._sqlBuilder.Length == 0)
{
shouldSortResults = true;
}
this._sqlBuilder.Append("SELECT ");
this.AppendDistinct(exp.IsDistinct);
if (exp.TakeCount != null)
{
this._sqlBuilder.Append("TOP ", exp.TakeCount.ToString(), " ");
}
string tableAlias = "T";
List <DbColumnSegment> columns = exp.ColumnSegments;
for (int i = 0; i < columns.Count; i++)
{
DbColumnSegment column = columns[i];
if (i > 0)
{
this._sqlBuilder.Append(",");
}
this.QuoteName(tableAlias);
this._sqlBuilder.Append(".");
this.QuoteName(column.Alias);
this._sqlBuilder.Append(" AS ");
this.QuoteName(column.Alias);
}
this._sqlBuilder.Append(" FROM ");
this._sqlBuilder.Append("(");
//------------------------//
this._sqlBuilder.Append("SELECT ");
for (int i = 0; i < columns.Count; i++)
{
DbColumnSegment column = columns[i];
if (i > 0)
{
this._sqlBuilder.Append(",");
}
DbValueExpressionTransformer.Transform(column.Body).Accept(this);
this._sqlBuilder.Append(" AS ");
this.QuoteName(column.Alias);
}
List <DbOrdering> orderings = exp.Orderings;
if (orderings.Count == 0)
{
DbOrdering ordering = new DbOrdering(PublicConstants.DbParameter_1, DbOrderType.Asc);
orderings = new List <DbOrdering>(1);
orderings.Add(ordering);
}
string row_numberName = GenRowNumberName(columns);
this._sqlBuilder.Append(",ROW_NUMBER() OVER(ORDER BY ");
this.ConcatOrderings(orderings);
this._sqlBuilder.Append(") AS ");
this.QuoteName(row_numberName);
this._sqlBuilder.Append(" FROM ");
exp.Table.Accept(this);
this.BuildWhereState(exp.Condition);
this.BuildGroupState(exp);
//------------------------//
this._sqlBuilder.Append(")");
this._sqlBuilder.Append(" AS ");
this.QuoteName(tableAlias);
this._sqlBuilder.Append(" WHERE ");
this.QuoteName(tableAlias);
this._sqlBuilder.Append(".");
this.QuoteName(row_numberName);
this._sqlBuilder.Append(" > ");
this._sqlBuilder.Append(exp.SkipCount.ToString());
if (shouldSortResults)
{
this._sqlBuilder.Append(" ORDER BY ");
this.QuoteName(tableAlias);
this._sqlBuilder.Append(".");
this.QuoteName(row_numberName);
this._sqlBuilder.Append(" ASC");
}
}
public abstract T Visit(DbSqlQueryExpression exp);
protected virtual void BuildLimitSql(DbSqlQueryExpression exp)
{
this._sqlBuilder.Append("SELECT ");
if (exp.TakeCount != null)
{
this._sqlBuilder.Append("TOP (", exp.TakeCount.ToString(), ") ");
}
string tableAlias = "T";
List <DbColumnSegment> columns = exp.ColumnSegments;
for (int i = 0; i < columns.Count; i++)
{
DbColumnSegment column = columns[i];
if (i > 0)
{
this._sqlBuilder.Append(",");
}
this.QuoteName(tableAlias);
this._sqlBuilder.Append(".");
this.QuoteName(column.Alias);
this._sqlBuilder.Append(" AS ");
this.QuoteName(column.Alias);
}
this._sqlBuilder.Append(" FROM ");
this._sqlBuilder.Append("(");
//------------------------//
this._sqlBuilder.Append("SELECT ");
for (int i = 0; i < columns.Count; i++)
{
DbColumnSegment column = columns[i];
if (i > 0)
{
this._sqlBuilder.Append(",");
}
column.Body.Accept(this.ValueExpressionVisitor);
this._sqlBuilder.Append(" AS ");
this.QuoteName(column.Alias);
}
List <DbOrdering> orderings = exp.Orderings;
if (orderings.Count == 0)
{
DbOrdering ordering = new DbOrdering(UtilConstants.DbParameter_1, OrderType.Asc);
orderings = new List <DbOrdering>(1);
orderings.Add(ordering);
}
string row_numberName = CreateRowNumberName(columns);
this._sqlBuilder.Append(",ROW_NUMBER() OVER(ORDER BY ");
this.ConcatOrderings(orderings);
this._sqlBuilder.Append(") AS ");
this.QuoteName(row_numberName);
this._sqlBuilder.Append(" FROM ");
exp.Table.Accept(this);
this.BuildWhereState(exp.Condition);
this.BuildGroupState(exp);
//------------------------//
this._sqlBuilder.Append(")");
this._sqlBuilder.Append(" AS ");
this.QuoteName(tableAlias);
this._sqlBuilder.Append(" WHERE ");
this.QuoteName(tableAlias);
this._sqlBuilder.Append(".");
this.QuoteName(row_numberName);
this._sqlBuilder.Append(" > ");
this._sqlBuilder.Append(exp.SkipCount.ToString());
}
public override DbExpression Visit(DbSqlQueryExpression exp)
{
return(exp.Accept(this._generator));
}
