/// <summary> /// Pivots the DataTable based on provided RowField, DataField, Aggregate Function and ColumnFields.// /// </summary> /// <param name="rowField">The column name of the Source Table which you want to spread into rows</param> /// <param name="dataField">The column name of the Source Table which you want to spread into Data Part</param> /// <param name="aggregate">The Aggregate function which you want to apply in case matching data found more than once</param> /// <param name="columnFields">The List of column names which you want to spread as columns</param> /// <returns>A DataTable containing the Pivoted Data</returns> public DataTable PivotData(string rowField, string dataField, AggregateFunction aggregate, params string[] columnFields) { DataTable dt = new DataTable(); string Separator = "."; List<string> rowList = _Source.Select(x => x[rowField].ToString()).Distinct().ToList(); // Gets the list of columns .(dot) separated. var colList = _Source.Select( x => (columnFields.Select(n => x[n]).Aggregate((a, b) => a += Separator + b.ToString())).ToString()) .Distinct() .OrderBy(m => m); dt.Columns.Add(rowField); foreach (var colName in colList) dt.Columns.Add(colName); // Cretes the result columns.// foreach (string rowName in rowList) { DataRow row = dt.NewRow(); row[rowField] = rowName; foreach (string colName in colList) { string strFilter = rowField + " = '" + rowName + "'"; string[] strColValues = colName.Split(Separator.ToCharArray(), StringSplitOptions.None); for (int i = 0; i < columnFields.Length; i++) strFilter += " and " + columnFields[i] + " = '" + strColValues[i] + "'"; row[colName] = GetData(strFilter, dataField, aggregate); } dt.Rows.Add(row); } return dt; }
/// <summary> /// Pivots the DataTable based on provided RowField, DataField, Aggregate Function and ColumnFields.// /// </summary> /// <param name="RowField">The column name of the Source Table which you want to spread into rows</param> /// <param name="DataField">The column name of the Source Table which you want to spread into Data Part</param> /// <param name="Aggregate">The Aggregate function which you want to apply in case matching data found more than once</param> /// <param name="ColumnFields">The List of column names which you want to spread as columns</param> /// <returns>A DataTable containing the Pivoted Data</returns> public DataTable PivotData(string RowField, string DataField, AggregateFunction Aggregate, params string[] ColumnFields) { DataTable dt = new DataTable(); string Separator = "."; var RowList = (from x in _SourceTable.AsEnumerable() select new { Name = x.Field<object>(RowField) }).Distinct(); // Gets the list of columns .(dot) separated. var ColList = (from x in _SourceTable.AsEnumerable() select new { Name = ColumnFields.Select(n => x.Field<object>(n)) .Aggregate((a, b) => a += Separator + b.ToString()) }) .Distinct() .OrderBy(m => m.Name); dt.Columns.Add(RowField); foreach (var col in ColList) { dt.Columns.Add(col.Name.ToString()); // Cretes the result columns.// } foreach (var RowName in RowList) { DataRow row = dt.NewRow(); row[RowField] = RowName.Name.ToString(); foreach (var col in ColList) { string strFilter = RowField + " = '" + RowName.Name + "'"; string[] strColValues = col.Name.ToString().Split(Separator.ToCharArray(), StringSplitOptions.None); for (int i = 0; i < ColumnFields.Length; i++) strFilter += " and " + ColumnFields[i] + " = '" + strColValues[i] + "'"; row[col.Name.ToString()] = GetData(strFilter, DataField, Aggregate); } dt.Rows.Add(row); } return dt; }
private string convertFunctionToString(AggregateFunction aggregate) { string result = ""; switch (aggregate) { case AggregateFunction.COUNT: { result = "COUNT"; break; } case AggregateFunction.AVERAGE: { result = "AVG"; break; } case AggregateFunction.MAX: { result = "MAX"; break; } case AggregateFunction.MIN: { result = "MIN"; break; } case AggregateFunction.SUM: { result = "SUM"; break; } } return result; }
public AggregateToken(AggregateFunction function, QueryToken parent) : base(parent) { if (function == AggregateFunction.Count) throw new ArgumentException("function should not different than Count for this overload"); if (parent == null) throw new ArgumentNullException("parent"); this.AggregateFunction = function; }
/// <summary> /// Initializes a new instance of the <see cref="AggregateResult"/> class. /// </summary> /// <param name="value">The value of the result.</param> /// <param name="count">The number of arguments used for the calculation of the result.</param> /// <param name="function">Function that generated the result.</param> /// <exception cref="ArgumentNullException"><c>function</c> is null.</exception> public AggregateResult(object value, int count, AggregateFunction function) { if (function == null) { throw new ArgumentNullException("function"); } aggregateValue = value; itemCount = count; this.function = function; }
public AggregateToken(AggregateFunction function, object queryName) : base(null) { if (function != AggregateFunction.Count) throw new ArgumentException("function should be Count for this overload"); if (queryName == null) throw new ArgumentNullException("queryName"); this.queryName = queryName; this.AggregateFunction = function; }
public DataTable CreateSpec(string[] DataFields, AggregateFunction[] Aggregate, string[] RowFields, string[] ColumnFields, double NSigma = 3) { DataTable dt = new DataTable(); try { var RowList = _SourceTable.DefaultView.ToTable(true, RowFields.Concat(ColumnFields).ToArray()).AsEnumerable().ToList(); for (int index = RowFields.Count() - 1; index >= 0; index--) RowList = RowList.OrderBy(x => x.Field<object>(RowFields[index])).ToList(); //dt.Columns.Add(RowFields); foreach (string s in RowFields) dt.Columns.Add(s); dt.Columns.Add("null"); //Extra column to seperate the input and output Hashtable FunHash = new Hashtable(); foreach (var fun in Aggregate) FunHash[fun] = "_" + fun.ToString(); FunHash[AggregateFunction.Average] = "_Typical"; foreach (string Data in DataFields) { foreach (var fun in Aggregate) if (!fun.ToString().Contains("Spec")) dt.Columns.Add(Data + FunHash[fun].ToString()); // Cretes the result columns.// dt.Columns.Add(Data + "_Delta"); //Correction factor } foreach (var RowName in RowList) { DataRow row = dt.NewRow(); string strFilter = string.Empty; string strSpecFilter = string.Empty; foreach (string Field in RowFields) { row[Field] = RowName[Field]; strFilter += " and " + Field + " = '" + RowName[Field].ToString() + "'"; } strFilter = strFilter.Substring(5); foreach (var fun in Aggregate) { string filter = strFilter; foreach (string Data in DataFields) if (!fun.ToString().Contains("Spec")) row[Data + FunHash[fun].ToString()] = GetData(new string[] { filter }, Data, fun); } dt.Rows.Add(row); } } catch (Exception ex) { errormsg = errormsg + "," + ex.Message; } return dt; }
public bool Delete(AggregateFunction entity) { Contract.Requires(entity != null); Contract.Requires(entity.Id >= 0); using (IUnitOfWork uow = this.GetUnitOfWork()) { IRepository<AggregateFunction> repo = uow.GetRepository<AggregateFunction>(); entity = repo.Reload(entity); //relation to DataContainer is managed by the other end repo.Delete(entity); uow.Commit(); } // if any problem was detected during the commit, an exception will be thrown! return (true); }
public AggregateFunction Create(string name, string description) { Contract.Requires(!string.IsNullOrWhiteSpace(name)); Contract.Ensures(Contract.Result<AggregateFunction>() != null && Contract.Result<AggregateFunction>().Id >= 0); AggregateFunction u = new AggregateFunction() { Name = name, Description = description, }; using (IUnitOfWork uow = this.GetUnitOfWork()) { IRepository<AggregateFunction> repo = uow.GetRepository<AggregateFunction>(); repo.Put(u); uow.Commit(); } return (u); }
/// <summary> /// Renders aggregate function as SQL element. /// </summary> /// <param name="aggregateFunction">Aggregate function.</param> /// <param name="dbms">Target DBMS.</param> /// <param name="output">StringBuilder to which SQL is appended.</param> /// <param name="allParameters">SQL parameter collection to which the object's and its children's /// parameters are added. After the rendering is done the collection contains all parameters with unique names.</param> public void Render(AggregateFunction aggregateFunction, DbmsType dbms, StringBuilder output, DbParameterCollection allParameters) { output.Append(aggregateFunction.Name); output.Append("("); if (aggregateFunction.Distinct) output.Append("DISTINCT "); if (aggregateFunction.FunctionArguments.Count > 0) { for (int paramIdx = 0; paramIdx < aggregateFunction.FunctionArguments.Count - 1; paramIdx++) { aggregateFunction.FunctionArguments[paramIdx].Render(dbms, output, allParameters); output.Append(", "); } aggregateFunction.FunctionArguments[aggregateFunction.FunctionArguments.Count - 1].Render(dbms, output, allParameters); } output.Append(")"); }
/// <exception cref="ArgumentException"> /// Provided <paramref name="enumerableExpression"/>'s <see cref="Expression.Type"/> is not <see cref="IEnumerable{T}"/> /// </exception> protected AggregateFunctionExpressionBuilderBase(Expression enumerableExpression, AggregateFunction function) : base(ExtractItemTypeFromEnumerableType(enumerableExpression.Type)) { this.enumerableExpression = enumerableExpression; this.function = function; }
/// <summary> /// Defining how a property of MainTableDataSource should be rendered as a column's cell. /// </summary> /// <param name="aggregateFunction">Using predefined aggregate functions.</param> public AggregateFunctionAttribute(AggregateFunction aggregateFunction) { AggregateFunction = aggregateFunction; }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(RedemptionCodeFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, expressionToExecute, aggregateToApply, null, null, null)); }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(RedemptionCodeFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }
public DataTable PivotData(string DataField, AggregateFunction[] Aggregate, string[] RowFields, string[] ColumnFields, double NSigma = 3) { DataTable dt = new DataTable(); try { string Separator = "~"; var RowList = _SourceTable.DefaultView.ToTable(true, RowFields).AsEnumerable().ToList(); for (int index = RowFields.Count() - 1; index >= 0; index--) RowList = RowList.OrderBy(x => x.Field<object>(RowFields[index])).ToList(); // Gets the list of columns .(dot) separated. var ColListFormula = (from x in _SourceTable.AsEnumerable() select new { Name = ColumnFields.Select(n => x.Field<object>(n)) .Aggregate((a, b) => a += Separator + b.ToString()) }) .Distinct() .OrderBy(m => m.Name); List<string> ColList = new List<string>(); if (!(ColumnFields == null)) if (ColumnFields.Length > 0) foreach (var col in ColListFormula) ColList.Add(col.Name.ToString()); //Include Spec filter DataColumnCollection Speccolumns = _SpecTable.Columns; bool ColumnFiledHasSpec = false; foreach (string col in ColumnFields) if (Speccolumns.Contains(col)) ColumnFiledHasSpec = true; //Add a column for Parameter and Unit dt.Columns.Add("Parameter"); //dt.Columns.Add(RowFields); foreach (string s in RowFields) dt.Columns.Add(s); bool SpecNeeded = false; foreach (var fun in Aggregate) if (fun.ToString().Contains("Spec")) SpecNeeded = true; if ((!ColumnFiledHasSpec) & SpecNeeded) { if (Aggregate.Contains(AggregateFunction.SpecMin)) dt.Columns.Add("SpecMin"); if (Aggregate.Contains(AggregateFunction.SpecMax)) dt.Columns.Add("SpecMax"); if (Aggregate.Contains(AggregateFunction.SpecTypical)) dt.Columns.Add("SpecTypical"); } if (ColumnFields.Length > 0) foreach (string col in ColList) { foreach (var fun in Aggregate) if (!fun.ToString().Contains("Spec")) dt.Columns.Add(col + '#' + fun.ToString()); // Cretes the result columns.// } else { foreach (var fun in Aggregate) if (!fun.ToString().Contains("Spec")) dt.Columns.Add(fun.ToString()); // Cretes the result columns.// } if (RowFields.Length > 0) { foreach (var RowName in RowList) { DataRow row = dt.NewRow(); row["Parameter"] = DataField; string strFilter = string.Empty; string strSpecFilter = string.Empty; foreach (string Field in RowFields) { row[Field] = RowName[Field]; strFilter += " and " + Field + " = '" + RowName[Field].ToString() + "'"; if (Speccolumns.Contains(Field)) strSpecFilter += " and " + Field + " = '" + RowName[Field].ToString() + "'"; } strFilter = strFilter.Substring(5); if (strSpecFilter.Length > 5) strSpecFilter = strSpecFilter.Substring(5); if (ColumnFields.Length > 0) { if ((!ColumnFiledHasSpec) & SpecNeeded) { string filter = strSpecFilter; if (Aggregate.Contains(AggregateFunction.SpecMin)) row["SpecMin"] = IncludeSpec(filter, DataField, "SpecMin"); if (Aggregate.Contains(AggregateFunction.SpecMax)) row["SpecMax"] = IncludeSpec(filter, DataField, "SpecMax"); if (Aggregate.Contains(AggregateFunction.SpecTypical)) row["SpecTypical"] = IncludeSpec(filter, DataField, "SpecTypical"); } foreach (string col in ColList) { string filter = strFilter; string[] strColValues = col.Split(Separator.ToCharArray(), StringSplitOptions.None); for (int i = 0; i < ColumnFields.Length; i++) filter += " and " + ColumnFields[i] + " = '" + strColValues[i] + "'"; foreach (var fun in Aggregate) { if (!fun.ToString().Contains("Spec")) { if (fun.ToString().Contains("CPK")) { object spec_max = IncludeSpec("", DataField, "SpecMax"); object spec_min = IncludeSpec("", DataField, "SpecMin"); if (spec_max.ToString() == "No Spec" || spec_min.ToString() == "No Spec") row[fun.ToString()] = "No Spec"; else row[fun.ToString()] = ObtainCPK(double.Parse(spec_max.ToString()), double.Parse(spec_min.ToString()), new string[] { filter }, DataField, NSigma); } else row[col + '#' + fun.ToString()] = GetData(new string[] { filter }, DataField, fun, NSigma); } else { //filter = strSpecFilter; //row[col + '#' + fun.ToString()] = IncludeSpec(filter, DataField, fun.ToString()); } } } } else { foreach (var fun in Aggregate) { string filter = strFilter; if (!fun.ToString().Contains("Spec")) { if (fun.ToString().Contains("CPK")) { object spec_max = IncludeSpec("", DataField, "SpecMax"); object spec_min = IncludeSpec("", DataField, "SpecMin"); if (spec_max.ToString() == "No Spec" || spec_min.ToString() == "No Spec") row[fun.ToString()] = "No Spec"; else row[fun.ToString()] = ObtainCPK(double.Parse(spec_max.ToString()), double.Parse(spec_min.ToString()), new string[] { filter }, DataField, NSigma); } else row[fun.ToString()] = GetData(new string[] { filter }, DataField, fun, NSigma); } else { filter = strSpecFilter; row[fun.ToString()] = IncludeSpec(filter, DataField, fun.ToString()); } } } dt.Rows.Add(row); } // foreach (var RowName in RowList) } //if (RowFields.Length > 0) else { DataRow row = dt.NewRow(); string strFilter = string.Empty; string strSpecFilter = string.Empty; if ((!ColumnFiledHasSpec) & SpecNeeded) { string filter = strSpecFilter; if (Aggregate.Contains(AggregateFunction.SpecMin)) row["SpecMin"] = IncludeSpec(filter, DataField, "SpecMin"); if (Aggregate.Contains(AggregateFunction.SpecMax)) row["SpecMax"] = IncludeSpec(filter, DataField, "SpecMax"); if (Aggregate.Contains(AggregateFunction.SpecTypical)) row["SpecTypical"] = IncludeSpec(filter, DataField, "SpecTypical"); } foreach (string col in ColList) { string filter = strFilter; string[] strColValues = col.Split(Separator.ToCharArray(), StringSplitOptions.None); for (int i = 0; i < ColumnFields.Length; i++) filter += " and " + ColumnFields[i] + " = '" + strColValues[i] + "'"; filter = filter.Substring(5); if (strSpecFilter.Length > 5) strSpecFilter = strSpecFilter.Substring(5); foreach (var fun in Aggregate) { if (!fun.ToString().Contains("Spec")) { if (fun.ToString().Contains("CPK")) { object spec_max = IncludeSpec("", DataField, "SpecMax"); object spec_min = IncludeSpec("", DataField, "SpecMin"); if (spec_max.ToString() == "No Spec" || spec_min.ToString() == "No Spec") row[fun.ToString()] = "No Spec"; else row[fun.ToString()] = ObtainCPK(double.Parse(spec_max.ToString()), double.Parse(spec_min.ToString()), new string[] { filter }, DataField, NSigma); } else row[col + '#' + fun.ToString()] = GetData(new string[] { filter }, DataField, fun, NSigma); } else { //filter = strSpecFilter; //row[col + '#' + fun.ToString()] = IncludeSpec(filter, DataField, fun.ToString()); } } } dt.Rows.Add(row); } } catch (Exception ex) { errormsg = errormsg + "," + ex.Message; } return dt; }
/// <summary> /// Initializes a new instance of the <see cref="AggregateResult"/> class. /// </summary> /// <param name="value">The value of the result.</param> /// <param name="function"><see cref="AggregateFunction"/> that generated the result.</param> public AggregateResult(object value, AggregateFunction function) : this(value, default(int), function) { }
/// <summary> /// Initializes a new instance of the <see cref="Aggregate"/> class. /// </summary> /// <param name="column">The column.</param> /// <param name="alias">The alias.</param> /// <param name="aggregateType">Type of the aggregate.</param> public Aggregate(TableSchema.TableColumn column, string alias, AggregateFunction aggregateType) { _columnName = column.QualifiedName; _alias = alias; _aggregateType = aggregateType; }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(AuditDataMessageRelatedFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }
private void CalculateAggregatesForInt(IEnumerable <TEntity> grouping, Func <TEntity, int> item, AggregateFunction function, string propertyName) { switch (function) { case AggregateFunction.Average: _aggregateProperties[propertyName] = grouping.Average(t => item(t)); break; case AggregateFunction.Max: _aggregateProperties[propertyName] = grouping.Max(t => item(t)); break; case AggregateFunction.Min: _aggregateProperties[propertyName] = grouping.Min(t => item(t)); break; case AggregateFunction.Sum: _aggregateProperties[propertyName] = grouping.Sum(t => item(t)); break; } }
public override string ToString() { return(AggregateFunction.NiceToString()); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <param name="filter">The filter to apply to retrieve the scalar</param> /// <param name="relations">The relations to walk</param> /// <param name="groupByClause">The groupby clause to apply to retrieve the scalar</param> /// <returns>the scalar value requested</returns> public virtual object GetScalar(ProductSubcategoryFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply, IPredicate filter, IRelationCollection relations, IGroupByCollection groupByClause) { EntityFields fields = new EntityFields(1); fields[0] = EntityFieldFactory.Create(fieldIndex); if ((fields[0].ExpressionToApply == null) || (expressionToExecute != null)) { fields[0].ExpressionToApply = expressionToExecute; } if ((fields[0].AggregateFunctionToApply == AggregateFunction.None) || (aggregateToApply != AggregateFunction.None)) { fields[0].AggregateFunctionToApply = aggregateToApply; } ProductSubcategoryDAO dao = DAOFactory.CreateProductSubcategoryDAO(); return(dao.GetScalar(fields, base.Transaction, filter, relations, groupByClause)); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(ProductSubcategoryFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, expressionToExecute, aggregateToApply, null, null, null)); }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(ProductSubcategoryFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }
public static DataSyncAction DropAggregateFunction(DataContext sourceDataContext, DataContext targetDataContext, AggregateFunction aggregateFunction) { var builder = new StringBuilder(); builder.Append(StartThe) .Append(aggregateFunction.Description) .Append(Space) .Append(aggregateFunction.Namespace) .Append(EndDropped); Func <string> script = () => ContextScriptFactory.DropAggregateFunction(sourceDataContext, targetDataContext, aggregateFunction); if (string.IsNullOrEmpty(script.Invoke())) { return(null); } return(new DataSyncAction( aggregateFunction , aggregateFunction.Namespace , builder.ToString() , DataSyncOperationType.DropAggregateFunction , script )); }
/// <summary> /// Initializes a new instance of the <see cref="Aggregate"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="alias">The alias.</param> /// <param name="aggregateType">Type of the aggregate.</param> public Aggregate(string columnName, string alias, AggregateFunction aggregateType) { _columnName = columnName; _aggregateType = aggregateType; _alias = alias; }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <param name="filter">The filter to apply to retrieve the scalar</param> /// <returns>the scalar value requested</returns> public object GetScalar(AuditDataMessageRelatedFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply, IPredicate filter) { return(GetScalar(fieldIndex, expressionToExecute, aggregateToApply, filter, null, null)); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(VendorContactFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, expressionToExecute, aggregateToApply, null, null, null)); }
/// <summary> /// Initializes a new instance of the <see cref="Aggregate"/> class. /// </summary> /// <param name="columnName">ColumnName of the column.</param> /// <param name="aggregateType">Type of the aggregate.</param> public Aggregate(string columnName, AggregateFunction aggregateType) { ColumnName = columnName; _aggregateType = aggregateType; Alias = String.Concat(GetFunctionType(this), "Of", columnName); }
public MembersAggregate(string name, Hierarchy hier, AggregateFunction aggr) : base(name, hier) { _aggregation=aggr ; this.Initialize(name); }
/// <summary> /// Initializes a new instance of the <see cref="Aggregate"/> class. /// </summary> /// <param name="columnName">ColumnName of the column.</param> /// <param name="alias">The alias.</param> /// <param name="aggregateType">Type of the aggregate.</param> public Aggregate(string columnName, string alias, AggregateFunction aggregateType) { ColumnName = columnName; _aggregateType = aggregateType; Alias = alias; }
public void CreateModule( Catalog catalog, IDataRecord reader) { var schemaName = Convert.ToString(reader[SchemaNameOrdinal]); var objectName = Convert.ToString(reader[ObjectNameOrdinal]); var typeDescription = Convert.ToString(reader[TypeDescriptionOrdinal]); var definition = Convert.ToString(reader[DefinitionOrdinal]); var usesAnsiNulls = Convert.ToBoolean(reader[UsesAnsiNullsOrdinal]); var usesQuotedIdentifier = Convert.ToBoolean(reader[UsesQuotedIdentifierOrdinal]); var isDisabled = Convert.ToBoolean(reader[IsDisabledOrdinal]); var isNotForReplication = Convert.ToBoolean(reader[IsNotForReplicationOrdinal]); var triggerForSchema = Convert.ToString(reader[TriggerForSchemaOrdinal]); var triggerForObjectName = Convert.ToString(reader[TriggerForObjectNameOrdinal]); var schema = catalog.Schemas[schemaName]; if (schema == null) { return; } switch (typeDescription) { case "AGGREGATE_FUNCTION": var aggregateFunction = new AggregateFunction { Schema = schema, ObjectName = objectName, Definition = definition, UsesAnsiNulls = usesAnsiNulls, UsesQuotedIdentifier = usesQuotedIdentifier }; schema.AggregateFunctions.Add(aggregateFunction); return; case "SQL_INLINE_TABLE_VALUED_FUNCTION": var inlineTableValuedFunction = new InlineTableValuedFunction { Schema = schema, ObjectName = objectName, Definition = definition, UsesAnsiNulls = usesAnsiNulls, UsesQuotedIdentifier = usesQuotedIdentifier }; schema.InlineTableValuedFunctions.Add(inlineTableValuedFunction); return; case "SQL_SCALAR_FUNCTION": case "FUNCTION": var scalarFunction = new ScalarFunction { Schema = schema, ObjectName = objectName, Definition = definition, UsesAnsiNulls = usesAnsiNulls, UsesQuotedIdentifier = usesQuotedIdentifier }; schema.ScalarFunctions.Add(scalarFunction); return; case "SQL_STORED_PROCEDURE": case "PROCEDURE": var storedProcedure = new StoredProcedure { Schema = schema, ObjectName = objectName, Definition = definition, UsesAnsiNulls = usesAnsiNulls, UsesQuotedIdentifier = usesQuotedIdentifier }; schema.StoredProcedures.Add(storedProcedure); return; case "SQL_TABLE_VALUED_FUNCTION": var tableValuedFunction = new TableValuedFunction { Schema = schema, ObjectName = objectName, Definition = definition, UsesAnsiNulls = usesAnsiNulls, UsesQuotedIdentifier = usesQuotedIdentifier }; schema.TableValuedFunctions.Add(tableValuedFunction); return; case "SQL_TRIGGER": case "TRIGGER": var trigger = new Trigger { Schema = schema, ObjectName = objectName, Definition = definition, UsesAnsiNulls = usesAnsiNulls, UsesQuotedIdentifier = usesQuotedIdentifier, IsDisabled = isDisabled, IsNotForReplication = isNotForReplication, TriggerForSchema = triggerForSchema, TriggerForObjectName = triggerForObjectName }; schema.Triggers.Add(trigger); return; case "VIEW": var view = new View { Schema = schema, ObjectName = objectName, Definition = definition, UsesAnsiNulls = usesAnsiNulls, UsesQuotedIdentifier = usesQuotedIdentifier }; schema.Views.Add(view); return; //case "CLR_SCALAR_FUNCTION": //case "CLR_STORED_PROCEDURE": //case "CLR_TABLE_VALUED_FUNCTION": //case "CLR_TRIGGER": } }
/// <summary> /// Initializes a new instance of the <see cref="Aggregate"/> class. /// </summary> /// <param name="column">The column.</param> /// <param name="aggregateType">Type of the aggregate.</param> public Aggregate(IDBObject column, AggregateFunction aggregateType) { ColumnName = column.QualifiedName; _aggregateType = aggregateType; Alias = String.Concat(GetFunctionType(this), "Of", column.Name); }
/// <summary> /// Initializes a new instance of the <see cref="Aggregate"/> class. /// </summary> /// <param name="column">The column.</param> /// <param name="alias">The alias.</param> /// <param name="aggregateType">Type of the aggregate.</param> public Aggregate(IDBObject column, string alias, AggregateFunction aggregateType) { ColumnName = column.QualifiedName; Alias = alias; _aggregateType = aggregateType; }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(ShipperFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }
private new void LoadFromXml(System.Xml.XmlElement xmlEl) { base.LoadFromXml(xmlEl); _aggregation = (AggregateFunction)System.Enum.Parse(typeof(AggregateFunction), xmlEl.GetAttribute("F")); Initialize(_name); }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(UriComponentFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }
private static object GetData(DataTable _SourceTable, string Filter, string DataField, AggregateFunction Aggregate) { try { DataRow[] FilteredRows = _SourceTable.Select(Filter); List<object> objList = FilteredRows.Select(x => x.Field<object>(DataField)).ToList(); switch (Aggregate) { case AggregateFunction.Average: { for (int i = 0; i < objList.Count(); i++) if (IsNumber(objList[i]) == false) objList.Remove(objList[i]); return objList.Average(x => float.Parse(x.ToString())); } case AggregateFunction.Count: return objList.Count(); case AggregateFunction.Exists: return (objList.Count() == 0) ? "False" : "True"; case AggregateFunction.First: return objList.FirstOrDefault(); case AggregateFunction.Last: return objList.LastOrDefault(); case AggregateFunction.Max: return objList.Max(); case AggregateFunction.Min: return objList.Min(); case AggregateFunction.Sum: { for (int i = 0; i < objList.Count(); i++) if (IsNumber(objList[i]) == false) objList[i] = 0; return objList.Sum(x => float.Parse(x.ToString())); } default: return null; } } catch (Exception ex) { return "#Error"; } }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(CampaignItemFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }
public MembersAggregate(string name, Hierarchy hier, AggregateFunction aggr) : base(name, hier) { _aggregation = aggr; this.Initialize(name); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(CampaignItemFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, expressionToExecute, aggregateToApply, null, null, null)); }
/// <summary> /// Initializes a new instance of the <see cref="Aggregate"/> class. /// </summary> /// <param name="columnName">Name of the column.</param> /// <param name="aggregateType">Type of the aggregate.</param> public Aggregate(string columnName, AggregateFunction aggregateType) { _columnName = columnName; _aggregateType = aggregateType; _alias = String.Concat(GetFunctionType(this), "Of", columnName); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <param name="filter">The filter to apply to retrieve the scalar</param> /// <param name="groupByClause">The groupby clause to apply to retrieve the scalar</param> /// <returns>the scalar value requested</returns> public object GetScalar(CampaignItemFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply, IPredicate filter, IGroupByCollection groupByClause) { return(GetScalar(fieldIndex, expressionToExecute, aggregateToApply, filter, null, groupByClause)); }
/// <summary> /// Initializes a new instance of the <see cref="Aggregate"/> class. /// </summary> /// <param name="column">The column.</param> /// <param name="aggregateType">Type of the aggregate.</param> public Aggregate(TableSchema.TableColumn column, AggregateFunction aggregateType) { _columnName = column.QualifiedName; _aggregateType = aggregateType; _alias = String.Concat(GetFunctionType(this), "Of", column.ColumnName); }
public DataTable PullPivotData(string DataField, AggregateFunction[] Aggregate, string[] RowFields, string[] ColumnFields, double NSigma = 3, int[] CurrentPosition = null) { DataTable dt = new DataTable(); DataTable dtp = new DataTable(); try { string Separator = "$#"; var RowList = _SourceTable.DefaultView.ToTable(true, RowFields).AsEnumerable().ToList(); for (int index = RowFields.Count() - 1; index >= 0; index--) RowList = RowList.OrderBy(x => x.Field<object>(RowFields[index])).ToList(); // Gets the list of columns .(dot) separated. var ColList = (from x in _SourceTable.AsEnumerable() select new { Name = ColumnFields.Select(n => x.Field<object>(n)) .Aggregate((a, b) => a += Separator + b.ToString()) }) .Distinct() .OrderBy(m => m.Name); //dt.Columns.Add(RowFields); foreach (string s in RowFields) dt.Columns.Add(s); if (ColumnFields.Length > 0) foreach (var col in ColList) foreach (var fun in Aggregate) dt.Columns.Add(col.Name.ToString() + '#' + fun.ToString()); // Cretes the result columns.// else foreach (var fun in Aggregate) dt.Columns.Add(fun.ToString()); // Cretes the result columns.// //Add Column names from Raw data foreach (DataColumn col in _SourceTable.Columns) dtp.Columns.Add(col.ColumnName.ToString()); int rowCount = 0; foreach (var RowName in RowList) { DataRow row = dt.NewRow(); rowCount++; string strFilter = string.Empty; foreach (string Field in RowFields) { row[Field] = RowName[Field]; strFilter += " and " + Field + " = '" + RowName[Field].ToString() + "'"; } strFilter = strFilter.Substring(5); if (ColumnFields.Length > 0) foreach (var col in ColList) { string filter = strFilter; string[] strColValues = col.Name.ToString().Split(Separator.ToCharArray(), StringSplitOptions.None); for (int i = 0; i < ColumnFields.Length; i++) filter += " and " + ColumnFields[i] + " = '" + strColValues[i] + "'"; if (rowCount == CurrentPosition[0] + 1) { DataRow[] FilteredRows = _SourceTable.Select(filter); foreach (DataRow rowEntry in FilteredRows) { dtp.ImportRow(rowEntry); } } } else { string filter = strFilter; if (rowCount == CurrentPosition[0] + 1) { DataRow[] FilteredRows = _SourceTable.Select(filter); foreach (DataRow rowEntry in FilteredRows) { dtp.ImportRow(rowEntry); } } } //dt.Rows.Add(row); } } catch (Exception ex) { } return dtp; }
/// <summary> /// Adds new aggregate result to collection. /// </summary> /// <param name="group">The group.</param> /// <param name="result">The aggregate result.</param> /// <param name="func">The aggregate function.</param> private static void AddAggregateResult(QueryableCollectionViewGroup group, Veyron.SharedTypes.AggregateResult result, AggregateFunction func) { var aggregateResult = new AggregateResult(result.Value, func); var r = result; var columnAggregates = group.AggregateResults .SkipWhile(x => !x.FunctionName.StartsWith(r.ColumnName, StringComparison.Ordinal)) .TakeWhile(x => x.FunctionName.StartsWith(r.ColumnName, StringComparison.Ordinal)) .ToList(); if (!columnAggregates.Any()) group.AggregateResults.Add(aggregateResult); else { var index = columnAggregates.TakeWhile(x => AggregateHelper.GetAttribute( AggregateHelper.GetTypeByFullName(x.Caption.Replace(":", null))).Order < AggregateHelper.GetAttribute(result.SummaryType).Order).Count(); if (columnAggregates.Count <= index) { var lastItemIndex = group.AggregateResults.IndexOf(columnAggregates.Last()); if (lastItemIndex == group.AggregateResults.Count - 1) group.AggregateResults.Add(aggregateResult); else group.AggregateResults.Insert(lastItemIndex + 1, aggregateResult); } else { var itemIndex = group.AggregateResults.IndexOf(columnAggregates[index]); group.AggregateResults.Insert(itemIndex, aggregateResult); } } }
public DataAttribute AddAggregateFunction(DataContainer container, AggregateFunction aggregateFunction) { throw new NotImplementedException(); }
/// <summary> /// Initializes a new instance of the <see cref="AggregateResult"/> class. /// </summary> /// <param name="function"><see cref="AggregateFunction"/> that generated the result.</param> /// <exception cref="ArgumentNullException"><c>function</c> is null.</exception> public AggregateResult(AggregateFunction function) : this(null, function) { }
private void initializeFunction(AggregateFunction aggregateFunction) { switch (aggregateFunction) { case AggregateFunction.Average: ColumnAggregateFunction = new Average { DisplayFormatFormula = DisplayFormatFormula }; break; case AggregateFunction.Maximum: ColumnAggregateFunction = new Maximum { DisplayFormatFormula = DisplayFormatFormula }; break; case AggregateFunction.Minimum: ColumnAggregateFunction = new Minimum { DisplayFormatFormula = DisplayFormatFormula }; break; case AggregateFunction.StdDev: ColumnAggregateFunction = new StdDev { DisplayFormatFormula = DisplayFormatFormula }; break; case AggregateFunction.Sum: ColumnAggregateFunction = new Sum { DisplayFormatFormula = DisplayFormatFormula }; break; case AggregateFunction.Variance: ColumnAggregateFunction = new Variance { DisplayFormatFormula = DisplayFormatFormula }; break; case AggregateFunction.Empty: ColumnAggregateFunction = new Empty { DisplayFormatFormula = DisplayFormatFormula }; break; default: throw new NotSupportedException("Please select a defined IAggregateFunction."); } }
private new void LoadFromXml(System.Xml.XmlElement xmlEl ) { base.LoadFromXml (xmlEl); _aggregation=(AggregateFunction)System.Enum.Parse(typeof(AggregateFunction) , xmlEl.GetAttribute("F")); Initialize(_name); }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(VendorContactFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }
/// <summary> /// Retrives the data for matching RowField value and ColumnFields values with Aggregate function applied on them. /// </summary> /// <param name="Filter">DataTable Filter condition as a string</param> /// <param name="DataField">The column name which needs to spread out in Data Part of the Pivoted table</param> /// <param name="Aggregate">Enumeration to determine which function to apply to aggregate the data</param> /// <returns></returns> public object GetData(string[] Filters, string DataField, AggregateFunction Aggregate, double NSigma = 3) { try { List<DataRow[]> FilteredRows = new List<DataRow[]>(); foreach (string filter in Filters) { FilteredRows.Add(_SourceTable.Select(filter)); } object[] objList = FilteredRows.Select(x => x.Select(y => y.Field<object>(DataField))).SelectMany(i => i).ToArray(); switch (Aggregate) { case AggregateFunction.Average: return GetAverage(objList); case AggregateFunction.Count: return objList.Count(); case AggregateFunction.Exists: return (objList.Count() == 0) ? "False" : "True"; case AggregateFunction.First: return GetFirst(objList); case AggregateFunction.Last: return GetLast(objList); case AggregateFunction.Max: return GetMax(objList); case AggregateFunction.Min: return GetMin(objList); case AggregateFunction.Sum: return GetSum(objList); case AggregateFunction.Stdev: return GetStdev(objList); case AggregateFunction.NSigmaPos: return GetNSigmaPos(objList, NSigma); case AggregateFunction.NSigmaNeg: return GetNSigmaNeg(objList, NSigma); case AggregateFunction.FullArray: return GetFullArray(objList); case AggregateFunction.NSigmaNegMin: List<object> minimumNSigmaNeg = new List<object>(); foreach (var e in FilteredRows) { minimumNSigmaNeg.Add(GetNSigmaNeg(e.Select(y => y.Field<object>(DataField)).ToArray(), NSigma)); } return GetMin(minimumNSigmaNeg.ToArray()); case AggregateFunction.NSigmaPosMax: List<object> maximumNSigmaPos = new List<object>(); foreach (var e in FilteredRows) { maximumNSigmaPos.Add(GetNSigmaPos(e.Select(y => y.Field<object>(DataField)).ToArray(), NSigma)); } return GetMax(maximumNSigmaPos.ToArray()); case AggregateFunction.NSigmaNegCorrespondingStdDev: List<Tuple<object, object>> correspondingNSigmaNeg = new List<Tuple<object, object>>(); foreach (var e in FilteredRows) { Tuple<object, object> stdDevNSigmaNed = new Tuple<object, object>(GetStdev(e.Select(y => y.Field<object>(DataField)).ToArray()), GetNSigmaNeg(e.Select(y => y.Field<object>(DataField)).ToArray(), NSigma)); correspondingNSigmaNeg.Add(stdDevNSigmaNed); } return correspondingNSigmaNeg.OrderBy(x => x.Item2).ToList()[0].Item1; case AggregateFunction.NSigmaPosCorrespondingStdDev: List<Tuple<object, object>> correspondingPSigmaPos = new List<Tuple<object, object>>(); foreach (var e in FilteredRows) { Tuple<object, object> stdDevNSigmaPos = new Tuple<object, object>(GetStdev(e.Select(y => y.Field<object>(DataField)).ToArray()), GetNSigmaPos(e.Select(y => y.Field<object>(DataField)).ToArray(), NSigma)); correspondingPSigmaPos.Add(stdDevNSigmaPos); } return correspondingPSigmaPos.OrderByDescending(x => x.Item2).ToList()[0].Item1; case AggregateFunction.NSigmaNegCorrespondingAvg: List<Tuple<object, object>> correspondingNSigmaAvg = new List<Tuple<object, object>>(); foreach (var e in FilteredRows) { Tuple<object, object> stdDevNSigmaNed = new Tuple<object, object>(GetAverage(e.Select(y => y.Field<object>(DataField)).ToArray()), GetNSigmaNeg(e.Select(y => y.Field<object>(DataField)).ToArray(), NSigma)); correspondingNSigmaAvg.Add(stdDevNSigmaNed); } return correspondingNSigmaAvg.OrderBy(x => x.Item2).ToList()[0].Item1; case AggregateFunction.NSigmaPosCorrespondingAvg: List<Tuple<object, object>> correspondingPSigmaAvg = new List<Tuple<object, object>>(); foreach (var e in FilteredRows) { Tuple<object, object> stdDevNSigmaPos = new Tuple<object, object>(GetAverage(e.Select(y => y.Field<object>(DataField)).ToArray()), GetNSigmaPos(e.Select(y => y.Field<object>(DataField)).ToArray(), NSigma)); correspondingPSigmaAvg.Add(stdDevNSigmaPos); } return correspondingPSigmaAvg.OrderByDescending(x => x.Item2).ToList()[0].Item1; default: return null; } } catch (Exception ex) { return "#Error"; } }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(CustomerCustomerDemoFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <param name="filter">The filter to apply to retrieve the scalar</param> /// <param name="relations">The relations to walk</param> /// <param name="groupByClause">The groupby clause to apply to retrieve the scalar</param> /// <returns>the scalar value requested</returns> public virtual object GetScalar(CampaignItemFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply, IPredicate filter, IRelationCollection relations, IGroupByCollection groupByClause) { EntityFields fields = new EntityFields(1); fields[0] = EntityFieldFactory.Create(fieldIndex); if ((fields[0].ExpressionToApply == null) || (expressionToExecute != null)) { fields[0].ExpressionToApply = expressionToExecute; } if ((fields[0].AggregateFunctionToApply == AggregateFunction.None) || (aggregateToApply != AggregateFunction.None)) { fields[0].AggregateFunctionToApply = aggregateToApply; } return(DAOFactory.CreateCampaignItemDAO().GetScalar(fields, this.Transaction, filter, relations, groupByClause)); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(CustomerCustomerDemoFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, expressionToExecute, aggregateToApply, null, null, null)); }
private Expression BindAggregate(Type resultType, AggregateFunction aggregateFunction, Expression source, LambdaExpression selector) { MetaProjectorExpression mp = AsProjection(Visit(source)); if (selector == null) return mp.Projector; Expression projector = MapAndVisit(selector, mp); return projector; }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(OrderDetailFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }
/// <summary> /// Predefined aggregate functions provider /// </summary> /// <param name="aggregateFunction">A set of a predefined aggregate functions.</param> public AggregateProvider(AggregateFunction aggregateFunction) { initializeFunction(aggregateFunction); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <param name="filter">The filter to apply to retrieve the scalar</param> /// <returns>the scalar value requested</returns> public object GetScalar(OrderDetailFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply, IPredicate filter) { return(GetScalar(fieldIndex, expressionToExecute, aggregateToApply, filter, null, null)); }
/// <summary>Creates the specified field on the position indexInResultset in the resultset.</summary> /// <param name="fieldToDefine">The specification of the field to create.</param> /// <param name="indexInResultset">The position in the resultset where the field will be created on</param> /// <param name="alias">The alias to use for this field in the resultset</param> /// <param name="entityAlias">The alias to use for the entity this field belongs to. Required to specify multiple times the same entity in a typed list</param> /// <param name="aggregateFunctionToApply">the aggregate function to apply to this field.</param> public void DefineField(ProductFieldIndex fieldToDefine, int indexInResultset, string alias, string entityAlias, AggregateFunction aggregateFunctionToApply) { IEntityField2 fieldToAdd = EntityFieldFactory.Create(fieldToDefine); fieldToAdd.Alias = alias; fieldToAdd.ObjectAlias = entityAlias; fieldToAdd.AggregateFunctionToApply = aggregateFunctionToApply; base[indexInResultset] = fieldToAdd; }
/// <summary> Gets a scalar value, calculated with the aggregate. the field index specified is the field the aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <returns>the scalar value requested</returns> public object GetScalar(CountryRegionFieldIndex fieldIndex, AggregateFunction aggregateToApply) { return(GetScalar(fieldIndex, null, aggregateToApply, null, null, null)); }