public override void ToPrecedenceFreeEPL(
TextWriter writer,
ExprNodeRenderableFlags flags)
{
writer.Write(_stateType?.GetNameInvariant());
ExprNodeUtilityPrint.ToExpressionStringParams(writer, this.ChildNodes);
}
private AggregationLinearFactoryDesc HandleCreateTable(
ExprNode[] childNodes,
AggregationAccessorLinearType?stateType,
ExprValidationContext validationContext)
{
var message = "For tables columns, the " +
stateType?.GetNameInvariant() +
" aggregation function requires the 'window(*)' declaration";
if (stateType != AggregationAccessorLinearType.WINDOW)
{
throw new ExprValidationException(message);
}
if (childNodes.Length == 0 || childNodes.Length > 1 || !(childNodes[0] is ExprWildcard))
{
throw new ExprValidationException(message);
}
if (validationContext.StreamTypeService.StreamNames.Length == 0)
{
throw new ExprValidationException(GetErrorPrefix(stateType) + " requires that the event type is provided");
}
var containedType = validationContext.StreamTypeService.EventTypes[0];
var componentType = containedType.UnderlyingType;
AggregationAccessorForge accessor = new AggregationAccessorWindowNoEvalForge(componentType);
AggregationStateFactoryForge stateFactory = new AggregationStateLinearForge(this, 0, null);
var factory = new AggregationForgeFactoryAccessLinear(
this,
accessor,
TypeHelper.GetArrayType(componentType),
null,
stateFactory,
null,
containedType);
var additionalForgeables = SerdeEventTypeUtility.Plan(
containedType,
validationContext.StatementRawInfo,
validationContext.SerdeEventTypeRegistry,
validationContext.SerdeResolver);
validationContext.AdditionalForgeables.AddAll(additionalForgeables);
return(new AggregationLinearFactoryDesc(factory, containedType, null, 0));
}
private static string GetErrorPrefix(AggregationAccessorLinearType?stateType)
{
var stateTypeString = stateType?.GetNameInvariant();
return(ExprAggMultiFunctionUtil.GetErrorPrefix(stateTypeString));
}
private AggregationLinearFactoryDesc HandleNonIntoTable(
ExprNode[] childNodes,
AggregationAccessorLinearType?stateType,
ExprValidationContext validationContext)
{
var streamTypeService = validationContext.StreamTypeService;
int streamNum;
Type resultType;
ExprForge forge;
ExprNode evaluatorIndex = null;
bool istreamOnly;
EventType containedType;
Type scalarCollectionComponentType = null;
// validate wildcard use
var isWildcard = childNodes.Length == 0 || childNodes.Length > 0 && childNodes[0] is ExprWildcard;
if (isWildcard)
{
ExprAggMultiFunctionUtil.ValidateWildcardStreamNumbers(validationContext.StreamTypeService, stateType?.GetNameInvariant());
streamNum = 0;
containedType = streamTypeService.EventTypes[0];
resultType = containedType.UnderlyingType;
var tableMetadataX = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(containedType);
forge = ExprNodeUtilityMake.MakeUnderlyingForge(0, resultType, tableMetadataX);
istreamOnly = GetIstreamOnly(streamTypeService, 0);
if ((stateType == AggregationAccessorLinearType.WINDOW) && istreamOnly && !streamTypeService.IsOnDemandStreams)
{
throw MakeUnboundValidationEx(stateType);
}
}
else if (childNodes.Length > 0 && childNodes[0] is ExprStreamUnderlyingNode)
{
// validate "stream.*"
streamNum = ExprAggMultiFunctionUtil.ValidateStreamWildcardGetStreamNum(childNodes[0]);
istreamOnly = GetIstreamOnly(streamTypeService, streamNum);
if ((stateType == AggregationAccessorLinearType.WINDOW) && istreamOnly && !streamTypeService.IsOnDemandStreams)
{
throw MakeUnboundValidationEx(stateType);
}
var type = streamTypeService.EventTypes[streamNum];
containedType = type;
resultType = type.UnderlyingType;
var tableMetadataX = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(type);
forge = ExprNodeUtilityMake.MakeUnderlyingForge(streamNum, resultType, tableMetadataX);
}
else
{
// validate when neither wildcard nor "stream.*"
var child = childNodes[0];
var streams = ExprNodeUtilityQuery.GetIdentStreamNumbers(child);
if (streams.IsEmpty() || (streams.Count > 1))
{
throw new ExprValidationException(
GetErrorPrefix(stateType) +
" requires that any child expressions evaluate properties of the same stream; Use 'firstever' or 'lastever' or 'nth' instead");
}
streamNum = streams.First();
istreamOnly = GetIstreamOnly(streamTypeService, streamNum);
if ((stateType == AggregationAccessorLinearType.WINDOW) && istreamOnly && !streamTypeService.IsOnDemandStreams)
{
throw MakeUnboundValidationEx(stateType);
}
resultType = childNodes[0].Forge.EvaluationType;
forge = childNodes[0].Forge;
if (streamNum >= streamTypeService.EventTypes.Length)
{
containedType = streamTypeService.EventTypes[0];
}
else
{
containedType = streamTypeService.EventTypes[streamNum];
}
scalarCollectionComponentType = resultType;
}
if (childNodes.Length > 1)
{
if (stateType == AggregationAccessorLinearType.WINDOW)
{
throw new ExprValidationException(GetErrorPrefix(stateType) + " does not accept an index expression; Use 'first' or 'last' instead");
}
evaluatorIndex = childNodes[1];
var indexResultType = evaluatorIndex.Forge.EvaluationType;
if (indexResultType != typeof(int?) && indexResultType != typeof(int))
{
throw new ExprValidationException(GetErrorPrefix(stateType) + " requires an index expression that returns an integer value");
}
}
// determine accessor
AggregationAccessorForge accessor;
if (evaluatorIndex != null)
{
var isFirst = stateType == AggregationAccessorLinearType.FIRST;
var constant = -1;
ExprForge forgeIndex;
if (evaluatorIndex.Forge.ForgeConstantType.IsCompileTimeConstant)
{
constant = evaluatorIndex.Forge.ExprEvaluator.Evaluate(null, true, null).AsInt32();
forgeIndex = null;
}
else
{
forgeIndex = evaluatorIndex.Forge;
}
accessor = new AggregationAccessorFirstLastIndexWEvalForge(streamNum, forge, forgeIndex, constant, isFirst);
}
else
{
if (stateType == AggregationAccessorLinearType.FIRST)
{
accessor = new AggregationAccessorFirstWEvalForge(streamNum, forge);
}
else if (stateType == AggregationAccessorLinearType.LAST)
{
accessor = new AggregationAccessorLastWEvalForge(streamNum, forge);
}
else if (stateType == AggregationAccessorLinearType.WINDOW)
{
accessor = new AggregationAccessorWindowWEvalForge(streamNum, forge, resultType);
}
else
{
throw new IllegalStateException("Access type is undefined or not known as code '" + stateType + "'");
}
}
var accessorResultType = resultType;
if (stateType == AggregationAccessorLinearType.WINDOW)
{
accessorResultType = TypeHelper.GetArrayType(resultType);
}
var isFafWindow = streamTypeService.IsOnDemandStreams && stateType == AggregationAccessorLinearType.WINDOW;
var tableMetadata = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(containedType);
if (tableMetadata == null && !isFafWindow && (istreamOnly || streamTypeService.IsOnDemandStreams))
{
if (optionalFilter != null)
{
positionalParams = ExprNodeUtilityMake.AddExpression(positionalParams, optionalFilter);
}
var serde = validationContext.SerdeResolver.SerdeForAggregation(accessorResultType, validationContext.StatementRawInfo);
AggregationForgeFactory factoryX = new AggregationForgeFactoryFirstLastUnbound(this, accessorResultType, optionalFilter != null, serde);
return(new AggregationLinearFactoryDesc(factoryX, containedType, scalarCollectionComponentType, streamNum));
}
var stateKey = new AggregationStateKeyWStream(
streamNum,
containedType,
AggregationStateTypeWStream.DATAWINDOWACCESS_LINEAR,
ExprNodeUtilityQuery.EMPTY_EXPR_ARRAY,
optionalFilter);
var optionalFilterForge = optionalFilter == null ? null : optionalFilter.Forge;
AggregationStateFactoryForge stateFactory = new AggregationStateLinearForge(this, streamNum, optionalFilterForge);
var factory = new AggregationForgeFactoryAccessLinear(
this,
accessor,
accessorResultType,
stateKey,
stateFactory,
AggregationAgentDefault.INSTANCE,
containedType);
var enumerationType = scalarCollectionComponentType == null ? containedType : null;
var serdeForgables = SerdeEventTypeUtility.Plan(
containedType,
validationContext.StatementRawInfo,
validationContext.SerdeEventTypeRegistry,
validationContext.SerdeResolver);
validationContext.AdditionalForgeables.AddAll(serdeForgables);
return(new AggregationLinearFactoryDesc(factory, enumerationType, scalarCollectionComponentType, streamNum));
}