private IEnumerable <DataSourceValueGroup> ExecuteSeriesFunction(Target sourceTarget, Tuple <SeriesFunction, string, GroupOperation> parsedFunction, DateTime startTime, DateTime stopTime, string interval, bool decimate, bool dropEmptySeries, CancellationToken cancellationToken)
{
SeriesFunction seriesFunction = parsedFunction.Item1;
string expression = parsedFunction.Item2;
GroupOperation groupOperation = parsedFunction.Item3;
// Parse out function parameters and target expression
Tuple <string[], string> expressionParameters = TargetCache <Tuple <string[], string> > .GetOrAdd(expression, () =>
{
List <string> parsedParameters = new List <string>();
// Extract any required function parameters
int requiredParameters = s_requiredParameters[seriesFunction]; // Safe: no lock needed since content doesn't change
// Any slice operation adds one required parameter for time tolerance
if (groupOperation == GroupOperation.Slice)
{
requiredParameters++;
}
if (requiredParameters > 0)
{
int index = 0;
for (int i = 0; i < requiredParameters && index > -1; i++)
{
index = expression.IndexOf(',', index + 1);
}
if (index > -1)
{
parsedParameters.AddRange(expression.Substring(0, index).Split(','));
}
if (parsedParameters.Count == requiredParameters)
{
expression = expression.Substring(index + 1).Trim();
}
else
{
throw new FormatException($"Expected {requiredParameters + 1} parameters, received {parsedParameters.Count + 1} in: {(groupOperation == GroupOperation.None ? "" : groupOperation.ToString())}{seriesFunction}({expression})");
}
}
// Extract any provided optional function parameters
int optionalParameters = s_optionalParameters[seriesFunction]; // Safe: no lock needed since content doesn't change
bool hasSubExpression(string target) => target.StartsWith("FILTER", StringComparison.OrdinalIgnoreCase) || target.Contains("(");
if (optionalParameters > 0)
{
int index = expression.IndexOf(',');
int lastIndex;
if (index > -1 && !hasSubExpression(expression.Substring(0, index)))
{
lastIndex = index;
for (int i = 1; i < optionalParameters && index > -1; i++)
{
index = expression.IndexOf(',', index + 1);
if (index > -1 && hasSubExpression(expression.Substring(lastIndex + 1, index - lastIndex - 1).Trim()))
{
index = lastIndex;
break;
}
lastIndex = index;
}
if (index > -1)
{
parsedParameters.AddRange(expression.Substring(0, index).Split(','));
expression = expression.Substring(index + 1).Trim();
}
}
}
return(new Tuple <string[], string>(parsedParameters.ToArray(), expression));
});
string[] parameters = expressionParameters.Item1;
string queryExpression = expressionParameters.Item2; // Final function parameter is always target expression
// When accurate calculation results are requested, query data source at full resolution
if (seriesFunction == SeriesFunction.Interval && ParseFloat(parameters[0]) == 0.0D)
{
decimate = false;
}
// Query function expression to get series data
IEnumerable <DataSourceValueGroup> dataset = QueryTarget(sourceTarget, queryExpression, startTime, stopTime, interval, decimate, dropEmptySeries, cancellationToken);
// Handle label function as a special edge case - group operations on label are ignored
if (seriesFunction == SeriesFunction.Label)
{
// Derive labels
string label = parameters[0];
if (label.StartsWith("\"") || label.StartsWith("'"))
{
label = label.Substring(1, label.Length - 2);
}
DataSourceValueGroup[] valueGroups = dataset.ToArray();
string[] seriesLabels = new string[valueGroups.Length];
for (int i = 0; i < valueGroups.Length; i++)
{
string target = valueGroups[i].RootTarget;
seriesLabels[i] = TargetCache <string> .GetOrAdd($"{label}@{target}", () =>
{
string table, derivedLabel;
string[] components = label.Split('.');
if (components.Length == 2)
{
table = components[0].Trim();
derivedLabel = components[1].Trim();
}
else
{
table = "ActiveMeasurements";
derivedLabel = label;
}
DataRow record = target.MetadataRecordFromTag(Metadata, table);
if (record != null && derivedLabel.IndexOf('{') >= 0)
{
foreach (string fieldName in record.Table.Columns.Cast <DataColumn>().Select(column => column.ColumnName))
{
derivedLabel = derivedLabel.ReplaceCaseInsensitive($"{{{fieldName}}}", record[fieldName].ToString());
}
}
// ReSharper disable once AccessToModifiedClosure
if (derivedLabel.Equals(label, StringComparison.Ordinal))
{
derivedLabel = $"{label}{(valueGroups.Length > 1 ? $" {i + 1}" : "")}";
}
return(derivedLabel);
});
}
// Verify that all series labels are unique
if (seriesLabels.Length > 1)
{
HashSet <string> uniqueLabelSet = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
for (int i = 0; i < seriesLabels.Length; i++)
{
while (uniqueLabelSet.Contains(seriesLabels[i]))
{
seriesLabels[i] = $"{seriesLabels[i]}\u00A0"; // Suffixing with non-breaking space for label uniqueness
}
uniqueLabelSet.Add(seriesLabels[i]);
}
}
for (int i = 0; i < valueGroups.Length; i++)
{
yield return(new DataSourceValueGroup
{
Target = seriesLabels[i],
RootTarget = valueGroups[i].RootTarget,
SourceTarget = sourceTarget,
Source = valueGroups[i].Source,
DropEmptySeries = dropEmptySeries
});
}
}
else
{
switch (groupOperation)
{
case GroupOperation.Set:
{
// Flatten all series into a single enumerable
DataSourceValueGroup valueGroup = new DataSourceValueGroup
{
Target = $"Set{seriesFunction}({string.Join(", ", parameters)}{(parameters.Length > 0 ? ", " : "")}{queryExpression})",
RootTarget = queryExpression,
SourceTarget = sourceTarget,
Source = ExecuteSeriesFunctionOverSource(dataset.AsParallel().WithCancellation(cancellationToken).SelectMany(source => source.Source), seriesFunction, parameters),
DropEmptySeries = dropEmptySeries
};
// Handle edge-case set operations - for these functions there is data in the target series as well
if (seriesFunction == SeriesFunction.Minimum || seriesFunction == SeriesFunction.Maximum || seriesFunction == SeriesFunction.Median)
{
DataSourceValue dataValue = valueGroup.Source.First();
valueGroup.Target = $"Set{seriesFunction} = {dataValue.Target}";
valueGroup.RootTarget = dataValue.Target;
}
yield return(valueGroup);
break;
}
case GroupOperation.Slice:
{
TimeSliceScanner scanner = new TimeSliceScanner(dataset, ParseFloat(parameters[0]) / SI.Milli);
parameters = parameters.Skip(1).ToArray();
foreach (DataSourceValueGroup valueGroup in ExecuteSeriesFunctionOverTimeSlices(scanner, seriesFunction, parameters, cancellationToken))
{
yield return(new DataSourceValueGroup
{
Target = $"Slice{seriesFunction}({string.Join(", ", parameters)}{(parameters.Length > 0 ? ", " : "")}{valueGroup.Target})",
RootTarget = valueGroup.RootTarget ?? valueGroup.Target,
SourceTarget = sourceTarget,
Source = valueGroup.Source,
DropEmptySeries = dropEmptySeries
});
}
break;
}
default:
{
foreach (DataSourceValueGroup valueGroup in dataset)
{
yield return(new DataSourceValueGroup
{
Target = $"{seriesFunction}({string.Join(", ", parameters)}{(parameters.Length > 0 ? ", " : "")}{valueGroup.Target})",
RootTarget = valueGroup.RootTarget ?? valueGroup.Target,
SourceTarget = sourceTarget,
Source = ExecuteSeriesFunctionOverSource(valueGroup.Source, seriesFunction, parameters),
DropEmptySeries = dropEmptySeries
});
}
break;
}
}
}
}
// Execute series function over a set of points from each series at the same time-slice
private static IEnumerable <DataSourceValueGroup> ExecuteSeriesFunctionOverTimeSlices(TimeSliceScanner scanner, SeriesFunction seriesFunction, string[] parameters, CancellationToken cancellationToken)
{
IEnumerable <DataSourceValue> readSliceValues()
{
while (!scanner.DataReadComplete && !cancellationToken.IsCancellationRequested)
{
foreach (DataSourceValue dataValue in ExecuteSeriesFunctionOverSource(scanner.ReadNextTimeSlice(), seriesFunction, parameters, true))
{
yield return(dataValue);
}
}
}
foreach (IGrouping <string, DataSourceValue> valueGroup in readSliceValues().GroupBy(dataValue => dataValue.Target))
{
yield return(new DataSourceValueGroup
{
Target = valueGroup.Key,
RootTarget = valueGroup.Key,
Source = valueGroup
});
}
}