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