private AggregationForgeFactoryAccessSorted HandleIntoTable(ExprValidationContext validationContext)
{
int streamNum;
if (positionalParams.Length == 0 ||
positionalParams.Length == 1 && positionalParams[0] is ExprWildcard) {
ExprAggMultiFunctionUtil.ValidateWildcardStreamNumbers(
validationContext.StreamTypeService,
AggregationFunctionName);
streamNum = 0;
}
else if (positionalParams.Length == 1 && positionalParams[0] is ExprStreamUnderlyingNode) {
streamNum = ExprAggMultiFunctionUtil.ValidateStreamWildcardGetStreamNum(positionalParams[0]);
}
else if (positionalParams.Length > 0) {
throw new ExprValidationException("When specifying into-table a sort expression cannot be provided");
}
else {
streamNum = 0;
}
var containedType = validationContext.StreamTypeService.EventTypes[streamNum];
var componentType = containedType.UnderlyingType;
var accessorResultType = componentType;
AggregationAccessorForge accessor;
if (!sortedwin) {
accessor = new AggregationAccessorMinMaxByNonTable(IsMax);
}
else {
accessor = new AggregationAccessorSortedNonTable(IsMax, componentType);
accessorResultType = TypeHelper.GetArrayType(accessorResultType);
}
AggregationAgentForge agent = AggregationAgentForgeFactory.Make(
streamNum,
optionalFilter,
validationContext.ImportService,
validationContext.StreamTypeService.IsOnDemandStreams,
validationContext.StatementName);
return new AggregationForgeFactoryAccessSorted(
this,
accessor,
accessorResultType,
containedType,
null,
null,
agent);
}
private AggregationLinearFactoryDesc HandleIntoTable(
ExprNode[] childNodes,
AggregationAccessorLinearType?stateType,
ExprValidationContext validationContext)
{
var message = "For into-table use 'window(*)' or 'window(stream.*)' instead";
if (stateType != AggregationAccessorLinearType.WINDOW)
{
throw new ExprValidationException(message);
}
if (childNodes.Length == 0 || childNodes.Length > 1)
{
throw new ExprValidationException(message);
}
if (validationContext.StreamTypeService.StreamNames.Length == 0)
{
throw new ExprValidationException(GetErrorPrefix(stateType) + " requires that at least one stream is provided");
}
int streamNum;
if (childNodes[0] is ExprWildcard)
{
if (validationContext.StreamTypeService.StreamNames.Length != 1)
{
throw new ExprValidationException(GetErrorPrefix(stateType) + " with wildcard requires a single stream");
}
streamNum = 0;
}
else if (childNodes[0] is ExprStreamUnderlyingNode)
{
var und = (ExprStreamUnderlyingNode)childNodes[0];
streamNum = und.StreamId;
}
else
{
throw new ExprValidationException(message);
}
var containedType = validationContext.StreamTypeService.EventTypes[streamNum];
var componentType = containedType.UnderlyingType;
AggregationAccessorForge accessor = new AggregationAccessorWindowNoEvalForge(componentType);
var agent = AggregationAgentForgeFactory.Make(
streamNum,
optionalFilter,
validationContext.ImportService,
validationContext.StreamTypeService.IsOnDemandStreams,
validationContext.StatementName);
var factory = new AggregationForgeFactoryAccessLinear(
this,
accessor,
TypeHelper.GetArrayType(componentType),
null,
null,
agent,
containedType);
return(new AggregationLinearFactoryDesc(factory, containedType, null, 0));
}