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