public virtual string GetHavingString(DataEntityMapping mapping, AggregateHavingExpression having, out DataParameter[] parameters, Dictionary <string, AggregateFunction> aggregateFunctionDictionary)
{
string havingString = null;
parameters = null;
if (having != null)
{
if (!having.IgnoreConsistency && !mapping.Equals(having.TableMapping))
{
throw new LightDataException(RE.DataMappingIsNotMatchAggregationExpression);
}
havingString = string.Format("having {0}", having.CreateSqlString(this, out parameters, new GetAliasHandler(delegate(object obj) {
string alias = null;
if (obj is AggregateFunction)
{
foreach (KeyValuePair <string, AggregateFunction> kv in aggregateFunctionDictionary)
{
if (Object.ReferenceEquals(obj, kv.Value))
{
alias = kv.Key;
break;
}
}
}
else
{
throw new LightDataException(RE.UnknowOrderType);
}
return(alias);
})));
}
return(havingString);
}
private static AggregateHavingExpression Catch(AggregateHavingExpression expression1, CatchOperatorsType operatorType, AggregateHavingExpression expression2)
{
if (expression1 == null && expression2 == null)
{
return(null);
}
else if (expression1 == null && expression2 != null)
{
return(expression2);
}
else if (expression1 != null && expression2 == null)
{
return(expression1);
}
if (expression1.TableMapping != expression2.TableMapping)
{
throw new LightDataException(RE.DataMappingOfExpressionIsNotMatch);
}
AggregateHavingExpression newExpression = new AggregateHavingExpression(expression1.TableMapping);
newExpression._expression1 = expression1;
newExpression._expression2 = expression2;
newExpression._operatorType = operatorType;
return(newExpression);
}
/// <summary>
/// 重置条件语句
/// </summary>
/// <returns>统计表生成器</returns>
public AggregateTable <T> Reset()
{
_query = null;
_order = null;
_having = null;
_level = SafeLevel.Default;
return(this);
}
/// <summary>
/// 匹配内容细节是否相等
/// </summary>
/// <param name="expression">匹配对象</param>
/// <returns></returns>
protected virtual bool EqualsDetail(AggregateHavingExpression expression)
{
if (this._expression1 != null)
{
return(this._expression1.Equals(expression._expression1) && this._expression2.Equals(expression._expression2) && this._operatorType == expression._operatorType);
}
else
{
return(Object.Equals(this.TableMapping, expression.TableMapping));
}
}
public override string GetHavingString(DataEntityMapping mapping, AggregateHavingExpression having, out DataParameter[] parameters, Dictionary <string, AggregateFunction> aggregateFunctionDictionary)
{
string havingString = null;
parameters = null;
if (having != null)
{
if (!having.IgnoreConsistency && !mapping.Equals(having.TableMapping))
{
throw new LightDataException(RE.DataMappingIsNotMatchAggregationExpression);
}
havingString = string.Format("having {0}", having.CreateSqlString(this, out parameters, new GetAliasHandler(delegate(object obj) {
return(null);
})));
}
return(havingString);
}
/// <summary>
/// 匹配内容是否相等
/// </summary>
/// <param name="target">匹配对象</param>
/// <returns></returns>
public virtual bool Equals(AggregateHavingExpression target)
{
if (Object.Equals(target, null))
{
return(false);
}
if (Object.ReferenceEquals(this, target))
{
return(true);
}
else
{
if (this.GetType() == target.GetType())
{
return(EqualsDetail(target));
}
else
{
return(false);
}
}
}
/// <summary>
/// 动态统计数据到数据集合中
/// </summary>
/// <param name="mapping">数据映射</param>
/// <param name="amapping">统计结果类型</param>
/// <param name="dataFieldInfoDictionary">统计字段信息</param>
/// <param name="aggregateFunctionDictionary">统计方法信息</param>
/// <param name="query">查询表达式</param>
/// <param name="having">统计查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="level">安全级别</param>
/// <returns>数据集合</returns>
internal IList QueryDynamicAggregateList(DataEntityMapping mapping, AggregateTableMapping amapping, Dictionary <string, DataFieldInfo> dataFieldInfoDictionary, Dictionary <string, AggregateFunction> aggregateFunctionDictionary, QueryExpression query, AggregateHavingExpression having, OrderExpression order, SafeLevel level)
{
if (amapping.RelateType != null && amapping.RelateType != mapping.ObjectType)
{
throw new LightDataException(string.Format(RE.AggregateTypeIsNotSpecifyType, amapping.RelateType.FullName));
}
using (IDbCommand command = _dataBase.Factory.CreateDynamicAggregateCommand(mapping, dataFieldInfoDictionary, aggregateFunctionDictionary, query, having, order))
{
IList items = CreateList(amapping.ObjectType);
IEnumerable ie = QueryDataReader(amapping, command, null, level);
foreach (object obj in ie)
{
items.Add(obj);
}
return(items);
}
}
/// <summary>
/// 动态统计数据到数据表中
/// </summary>
/// <param name="mapping">数据映射</param>
/// <param name="dataFieldInfoDictionary">统计字段信息</param>
/// <param name="aggregateFunctionDictionary">统计方法信息</param>
/// <param name="query">查询表达式</param>
/// <param name="having">统计查询表达式</param>
/// <param name="order">排序表达式</param>
/// <param name="level">安全级别</param>
/// <returns>数据表</returns>
internal DataTable QueryDynamicAggregateTable(DataEntityMapping mapping, Dictionary <string, DataFieldInfo> dataFieldInfoDictionary, Dictionary <string, AggregateFunction> aggregateFunctionDictionary, QueryExpression query, AggregateHavingExpression having, OrderExpression order, SafeLevel level)
{
using (IDbCommand command = _dataBase.Factory.CreateDynamicAggregateCommand(mapping, dataFieldInfoDictionary, aggregateFunctionDictionary, query, having, order))
{
return(QueryDataTable(command, null, level));
}
}
public virtual IDbCommand CreateDynamicAggregateCommand(DataEntityMapping mapping, Dictionary <string, DataFieldInfo> dataFieldInfoDictionary, Dictionary <string, AggregateFunction> aggregateFunctionDictionary, QueryExpression query, AggregateHavingExpression having, OrderExpression order)
{
if (dataFieldInfoDictionary == null || dataFieldInfoDictionary.Count == 0)
{
throw new LightDataException(RE.DynamicAggregateFieldIsNotExists);
}
StringBuilder sql = new StringBuilder();
StringBuilder select = new StringBuilder();
StringBuilder groupby = new StringBuilder();
List <DataParameter> parameterlist = new List <DataParameter> ();
bool flat = false;
foreach (KeyValuePair <string, DataFieldInfo> kv in dataFieldInfoDictionary)
{
if (!mapping.Equals(kv.Value.TableMapping))
{
throw new LightDataException(RE.DataMappingIsNotMatchAggregateField);
}
string groupbyField = kv.Value.CreateDataFieldSql(this);
string aliasName = CreateDataFieldSql(kv.Key);
string selectField = string.Format("{0} as {1}", groupbyField, aliasName);
if (!flat)
{
flat = true;
}
else
{
selectField = "," + selectField;
groupbyField = "," + groupbyField;
}
select.Append(selectField);
groupby.Append(groupbyField);
}
foreach (KeyValuePair <string, AggregateFunction> kv in aggregateFunctionDictionary)
{
if (kv.Value.TableMapping != null && !mapping.Equals(kv.Value.TableMapping))
{
throw new LightDataException(RE.DataMappingIsNotMatchAggregateField);
}
DataParameter[] aggparameters = null;
string aggField = kv.Value.CreateSqlString(this, out aggparameters);
string aliasName = CreateDataFieldSql(kv.Key);
string selectField = string.Format(",{0} as {1}", aggField, aliasName);
select.Append(selectField);
parameterlist.AddRange(aggparameters);
}
sql.AppendFormat("select {0} from {1}", select, CreateDataTableSql(mapping.TableName));
DataParameter[] queryparameters = null;
string queryString = GetQueryString(mapping, query, out queryparameters);
DataParameter[] havingparameters = null;
string havingString = GetHavingString(mapping, having, out havingparameters, aggregateFunctionDictionary);
DataParameter[] orderbyparameters = null;
string orderString = GetOrderString(mapping, order, out orderbyparameters, dataFieldInfoDictionary, aggregateFunctionDictionary);
if (!string.IsNullOrEmpty(queryString))
{
sql.AppendFormat(" {0}", queryString);
parameterlist.AddRange(queryparameters);
}
sql.AppendFormat(" group by {0}", groupby);
if (!string.IsNullOrEmpty(havingString))
{
sql.AppendFormat(" {0}", havingString);
parameterlist.AddRange(havingparameters);
}
if (!string.IsNullOrEmpty(orderString))
{
sql.AppendFormat(" {0}", orderString);
parameterlist.AddRange(orderbyparameters);
}
IDbCommand command = BuildCommand(sql.ToString(), parameterlist.ToArray());
return(command);
}
internal static AggregateHavingExpression Or(AggregateHavingExpression expression1, AggregateHavingExpression expression2)
{
return(Catch(expression1, CatchOperatorsType.OR, expression2));
}
/// <summary>
/// 添加统计够查询条件
/// </summary>
/// <param name="expression">查询表达式</param>
/// <returns>统计表生成器</returns>
public AggregateTable <T> Having(AggregateHavingExpression expression)
{
_having &= expression;
return(this);
}
