protected void AddPagingClause(StringBuilder sb, QueryBuildInfo buildInfo, QueryStructure structure)
{
long pageSize = structure.Fetch;
long currentOffset = structure.Skip;
if (currentOffset > 0 && pageSize == 0)
{
pageSize = long.MaxValue;
}
if (pageSize > 0)
{
sb.Append(" LIMIT ? ");
QueryExecParam param = new QueryExecParam();
param.Index = buildInfo.ExecInfo.Params.Count;
param.Type = ColumnType.Long;
param.Value = pageSize;
buildInfo.ExecInfo.Params.Add(param);
}
if (currentOffset > 0)
{
sb.Append(" OFFSET ? ");
QueryExecParam param = new QueryExecParam();
param.Index = buildInfo.ExecInfo.Params.Count;
param.Type = ColumnType.Long;
param.Value = currentOffset;
buildInfo.ExecInfo.Params.Add(param);
}
}
public object Retrieve(IDataReader rs, ITransaction tx, QueryBuildInfo buildInfo)
{
try
{
string column = null;
ISegment rootSegment = Expr.RootSegment;
FieldSegment fieldSegment = null;
switch (rootSegment.SegmentType)
{
case SegmentType.Group:
fieldSegment = ((GroupFunctionSegment)rootSegment).SegmentToGroup;
column = GetColumnName(fieldSegment, buildInfo);
break;
case SegmentType.Field:
fieldSegment = (FieldSegment)rootSegment;
column = GetColumnName(fieldSegment, buildInfo);
break;
case SegmentType.Query:
var querySegment = (QuerySegment)rootSegment;
column = querySegment.Alias;
break;
}
int ordinal = rs.GetOrdinal(column);
Object obj = rs.GetValue(ordinal);
return(obj);
}
catch (Exception ex)
{
throw new RetrievalException(ex.Message, ex);
}
}
private void CreateJoinExpressionForDefinedRelation(QueryBuildInfo buildInfo)
{
string typeFromAlias = buildInfo.GetAlias(TypeFrom);
IRelation relation = processor.GetRelation(TypeFrom, TypeTo);
if (relation == null)
{
relation = processor.GetRelation(TypeTo, TypeFrom);
}
if (relation != null)
{
Expr = JoinExpr.Build();
ICollection <RelationColumnMapping> tableColumnMappings = relation.TableColumnMappings;
int i = 0;
foreach (RelationColumnMapping mapping in tableColumnMappings)
{
if (i > 0)
{
Expr.And();
}
Expr.Field(TypeFrom, typeFromAlias, mapping.FromField);
Expr.Eq();
Expr.Field(TypeTo, TypeToAlias, mapping.ToField);
i++;
}
}
}
private string GetColumnName(FieldSegment fieldSegment, QueryBuildInfo buildInfo)
{
string alias = fieldSegment.Alias;
string column = !string.IsNullOrEmpty(alias) ? alias : _processor.GetColumn(fieldSegment, buildInfo).ColumnName;
return(column);
}
public string CreateSql(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
String alias = "union_src_" + Guid.NewGuid().ToString().Substring(0, 5);
var sqlBuilder = new StringBuilder();
sqlBuilder.Append("(");
for (int i = 0, queriesLength = Queries.Length; i < queriesLength; i++)
{
ISelectionQuery query = Queries[i];
QueryBuildInfo result = dbLayer.DataManipulate().ProcessQuery(buildInfo, query.Structure);
if (i > 0)
{
sqlBuilder.Append(" UNION ");
if (All)
{
sqlBuilder.Append(" ALL ");
}
}
sqlBuilder.Append(result.ExecInfo.Sql + " union_src_" + i);
}
sqlBuilder.Append(") ").Append(alias);
buildInfo.AddUnionAlias(alias);
return(sqlBuilder.ToString());
}
private void ProcessSelection(StringBuilder querySb, QueryBuildInfo buildInfo, QueryStructure structure)
{
var selectionSb = new StringBuilder();
selectionSb.Append("SELECT ");
if (structure.SelectList.Count == 0)
{
selectionSb.Append(" * ");
}
if (structure.Distinct)
{
selectionSb.Append(" DISTINCT ");
}
ICollection <IQuerySelection> selections = structure.SelectList;
bool initial = true;
foreach (IQuerySelection selection in selections)
{
if (!initial)
{
selectionSb.Append(",");
}
selectionSb.Append(CreateSelectionSql(selection, buildInfo));
initial = false;
}
querySb.Insert(0, selectionSb.ToString());
}
protected string CreateWhereSql(IQueryCondition condition, QueryBuildInfo buildInfo)
{
if (condition != null)
{
return(((IAbstractCondition)condition).CreateSql(_dbLayer, buildInfo));
}
return("/*Incorrect Where*/");
}
protected string CreateJoinSql(IQueryJoin join, QueryBuildInfo buildInfo)
{
if (join != null)
{
return(((IAbstractJoin)join).CreateSql(_dbLayer, buildInfo));
}
return("/*Incorrect Join*/");
}
public string CreateSql(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
if (Expr == null)
{
CreateJoinExpressionForDefinedRelation(buildInfo);
}
return(CreateSqlForExpression(dbLayer, buildInfo));
}
protected string CreateFromSql(IQueryFrom from, QueryBuildInfo buildInfo)
{
if (from != null)
{
return(((IAbstractFrom)from).CreateSql(_dbLayer, buildInfo));
}
return("/*Incorrect From*/");
}
protected string CreateSelectionSql(IQuerySelection selection, QueryBuildInfo buildInfo)
{
if (selection != null)
{
return(((IAbstractSelection)selection).CreateSql(_dbLayer, buildInfo));
}
return("/*Incorrect Selection*/");
}
protected string CreateOrderBySql(IQueryOrderBy orderBy, QueryBuildInfo buildInfo)
{
if (orderBy != null)
{
return(((IAbstractOrderBy)orderBy).CreateSql(_dbLayer, buildInfo));
}
return("/*Incorrect Order by*/");
}
protected string CreateGroupSql(IQueryGroup group, QueryBuildInfo buildInfo)
{
if (group != null)
{
return(((IAbstractGroup)group).CreateSql(_dbLayer, buildInfo));
}
return("/*Incorrect Group*/");
}
public string CreateSql(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
var aliases = buildInfo.GetAlias(EntityType);
if (!string.IsNullOrEmpty(aliases))
{
return(aliases + ".*");
}
return("*");
}
public string CreateSql(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
ISegment rootSegment = Expr.RootSegment;
switch (rootSegment.SegmentType)
{
case SegmentType.Field:
return(_processor.GetFieldName((FieldSegment)rootSegment, false, buildInfo));
}
return(null);
}
public string CreateSql(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
EntityInfo entityInfo = CacheManager.GetEntityInfo(EntityType);
string sql = entityInfo.TableInfo.TableName;
if (!string.IsNullOrEmpty(Alias))
{
sql = sql + " as " + Alias;
buildInfo.AddTypeAlias(Alias, EntityType);
}
return(sql);
}
public string CreateSql(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
QueryBuildInfo result = dbLayer.DataManipulate().ProcessQuery(buildInfo, Query.Structure);
string sql = "(" + result.ExecInfo.Sql + ")";
if (!string.IsNullOrEmpty(Alias))
{
sql = sql + " as " + Alias;
buildInfo.AddQueryAlias(Alias, Query);
}
return(sql);
}
public Object Retrieve(IDataReader rs, ITransaction tx, QueryBuildInfo buildInfo)
{
try
{
var instance = (IReadOnlyEntity)Activator.CreateInstance(EntityType);
instance.Retrieve(rs, tx);
return(instance);
}
catch (Exception ex)
{
throw new RetrievalException(ex.Message, ex);
}
}
private String CreateSqlForExpression(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
var from = new AbstractTypeFrom();
from.EntityType = TypeTo;
from.Alias = TypeToAlias;
var sb = new StringBuilder();
AppendJoinTypeSql(sb);
sb.Append(from.CreateSql(dbLayer, buildInfo));
sb.Append(" ON ");
processor.Process(sb, Expr.RootSegment, buildInfo, dbLayer);
return(sb.ToString());
}
private void ProcessJoin(StringBuilder sb, QueryBuildInfo buildInfo, QueryStructure structure)
{
var joinList = structure.JoinList;
if (joinList.Count == 0)
{
return;
}
foreach (var join in joinList)
{
sb.Append(" ");
sb.Append(CreateJoinSql(join, buildInfo));
}
}
private void ProcessFrom(StringBuilder sb, QueryBuildInfo buildInfo, QueryStructure structure)
{
sb.Append(" FROM ");
ICollection <IQueryFrom> fromList = structure.FromList;
bool initial = true;
foreach (IQueryFrom from in fromList)
{
if (!initial)
{
sb.Append(",");
}
sb.Append(CreateFromSql(from, buildInfo));
initial = false;
}
}
public string CreateSql(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
ISegment rootSegment = Expr.RootSegment;
switch (rootSegment.SegmentType)
{
case SegmentType.Group:
return(_processor.GetGroupFunction((GroupFunctionSegment)rootSegment, true, buildInfo));
case SegmentType.Field:
return(_processor.GetFieldName((FieldSegment)rootSegment, true, buildInfo));
case SegmentType.Query:
var querySegment = (QuerySegment)rootSegment;
buildInfo = dbLayer.DataManipulate().ProcessQuery(buildInfo, querySegment.Query.Structure);
return("(" + buildInfo.ExecInfo.Sql + ") as " + querySegment.Alias);
}
return(null);
}
public QueryBuildInfo ProcessQuery(QueryBuildInfo buildInfo, QueryStructure structure)
{
buildInfo = new QueryBuildInfo(buildInfo);
buildInfo.CurrentQueryId = structure.QueryId;
StringBuilder sb = new StringBuilder();
ProcessFrom(sb, buildInfo, structure);
ProcessJoin(sb, buildInfo, structure);
ProcessWhere(sb, buildInfo, structure);
ProcessGroup(sb, buildInfo, structure);
ProcessGroupCondition(sb, buildInfo, structure);
ProcessOrderBy(sb, buildInfo, structure);
AddPagingClause(sb, buildInfo, structure);
ProcessSelection(sb, buildInfo, structure);
buildInfo.ExecInfo.Sql = FixUpQuery(sb.ToString());
return(buildInfo);
}
public Object Retrieve(IDataReader rs, ITransaction tx, QueryBuildInfo buildInfo)
{
try
{
IList <String> columns = new List <string>();
string[] segments = Regex.Split(Sql, "\\s*,\\s*");
foreach (string segment in segments)
{
if (segment.Trim().Length == 0)
{
continue;
}
columns.Add(segment.Trim());
}
var readObjects = new Object[columns.Count];
for (int i = 0, columnsLength = columns.Count; i < columnsLength; i++)
{
String column = columns[i].ToLowerInvariant();
if (column.Contains(" as "))
{
column = column.Split(new[] { "as" }, StringSplitOptions.RemoveEmptyEntries)[1].Trim();
}
int ordinal = rs.GetOrdinal(column);
Object obj = rs.GetValue(ordinal);
readObjects[i] = obj;
}
if (readObjects.Length == 1)
{
return(readObjects[0]);
}
return(readObjects);
}
catch (Exception ex)
{
throw new RetrievalException(ex.Message, ex);
}
}
public string CreateSql(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
ISegment rootSegment = Expr.RootSegment;
switch (rootSegment.SegmentType)
{
case SegmentType.Field:
String sql = _processor.GetFieldName((FieldSegment)rootSegment, false, buildInfo);
switch (OrderType)
{
case QueryOrderType.Ascend:
sql += " ASC";
break;
case QueryOrderType.Descend:
sql += " DESC";
break;
}
return(sql);
}
return(null);
}
private void ProcessWhere(StringBuilder sb, QueryBuildInfo buildInfo, QueryStructure structure)
{
ICollection <IQueryCondition> conditionList = structure.ConditionList;
if (conditionList.Count == 0)
{
return;
}
sb.Append(" WHERE ");
bool initial = true;
foreach (IQueryCondition condition in conditionList)
{
if (!initial)
{
sb.Append(" AND ");
}
sb.Append(CreateWhereSql(condition, buildInfo));
initial = false;
}
}
private void ProcessGroup(StringBuilder sb, QueryBuildInfo buildInfo, QueryStructure structure)
{
ICollection <IQueryGroup> groupList = structure.GroupList;
if (groupList.Count == 0)
{
return;
}
sb.Append(" GROUP BY ");
bool initial = true;
foreach (IQueryGroup group in groupList)
{
if (!initial)
{
sb.Append(",");
}
sb.Append(CreateGroupSql(group, buildInfo));
initial = false;
}
}
private void ProcessGroupCondition(StringBuilder sb, QueryBuildInfo buildInfo, QueryStructure structure)
{
ICollection <IQueryGroupCondition> groupConditionList = structure.GroupConditionList;
if (groupConditionList.Count == 0)
{
return;
}
sb.Append(" HAVING ");
bool initial = true;
foreach (IQueryGroupCondition groupCondition in groupConditionList)
{
if (!initial)
{
sb.Append(" AND ");
}
sb.Append(CreateGroupConditionSql(groupCondition, buildInfo));
initial = false;
}
}
private void ProcessOrderBy(StringBuilder sb, QueryBuildInfo buildInfo, QueryStructure structure)
{
ICollection <IQueryOrderBy> orderList = structure.OrderList;
if (orderList.Count == 0)
{
return;
}
sb.Append(" ORDER BY ");
bool initial = true;
foreach (IQueryOrderBy orderBy in orderList)
{
if (!initial)
{
sb.Append(",");
}
sb.Append(CreateOrderBySql(orderBy, buildInfo));
initial = false;
}
}
public string CreateSql(IDbLayer dbLayer, QueryBuildInfo buildInfo)
{
return(Sql);
}
