Example #1
0
        protected override List <TplResult> InnerProcess(List <TplResult> inputs)
        {
            var results = new List <TplResult>();

            if (inputs.Count > 0)
            {
                results.Add(inputs[0]);

                var targetFields = TargetFields == null || !TargetFields.Any() ? inputs.GetAllFields() : TargetFields;

                if (Mode == DedupMode.All)
                {
                    for (int j = 1; j < inputs.Count; j++)
                    {
                        var  input        = inputs[j];
                        bool alreadyAdded = false;

                        for (int i = 0; i < results.Count; i++)
                        {
                            var result = results[i];

                            alreadyAdded |= result.Matches(input, targetFields);

                            if (alreadyAdded)
                            {
                                if (SortMode == DedupSort.Last)
                                {
                                    results[i] = input;
                                }
                                break;
                            }
                        }

                        if (!alreadyAdded)
                        {
                            results.Add(input);
                        }
                    }
                }

                else if (Mode == DedupMode.Consecutive)
                {
                    foreach (var result in inputs)
                    {
                        if (!result.Matches(results.Last(), targetFields))
                        {
                            results.Add(result);
                        }
                    }
                }
            }

            return(results);
        }
Example #2
0
        protected override List <TplResult> InnerProcess(List <TplResult> input)
        {
            if ((Sum || Avg) && !TargetFields.Any())
            {
                throw new InvalidOperationException("Stats function requires at least one target field to be specified when calculating sum/average");
            }

            if (!input.Any())
            {
                return(input);
            }

            var results = new List <TplResult>();

            // If no 'By Fields' are specified, all results will end up in one big group
            var groupByResult = input
                                .GroupBy(r => ByFields.Aggregate("", (t, b) => t + r.StringValueOf(b)))
                                .Select(g => new
            {
                FinalResult = g.First().Copy(),
                WholeGroup  = g.ToList(),
                Sums        = TargetFields.ToDictionary(f => f, _ => 0.0)
            })
                                .ToList();

            var tplSelectFields = ByFields.ToList();

            // Target fields do not matter for Count
            if (Count)
            {
                foreach (var group in groupByResult)
                {
                    var newField = "Count";
                    group.FinalResult.AddOrUpdateField(newField, group.WholeGroup.Count);
                    tplSelectFields.Add(newField);
                }
            }

            // Target fields must be specified for Sum and Avg
            if (Sum || Avg)
            {
                //Calculate the Sum (Needed for average anyway)
                foreach (var group in groupByResult)
                {
                    foreach (var field in TargetFields)
                    {
                        var value = group.WholeGroup.Aggregate(0.0, (total, next) => total + next.NumericValueOf(field));
                        group.Sums[field] = value;
                        if (Sum)
                        {
                            var newField = field + "_Sum";
                            group.FinalResult.AddOrUpdateField(newField, value);
                            tplSelectFields.Add(newField);
                        }
                    }
                }

                if (Avg)
                {
                    foreach (var group in groupByResult)
                    {
                        foreach (var field in TargetFields)
                        {
                            var newField = field + "_Avg";
                            group.FinalResult.AddOrUpdateField(newField, group.Sums[field] / group.WholeGroup.Count);
                            tplSelectFields.Add(newField);
                        }
                    }
                }
            }

            var select = new TplSelect(tplSelectFields);

            return(select.Process(groupByResult.Select(g => g.FinalResult)));
        }