internal override void Assign(
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block
.SetProperty(
factory,
"SizeEvaluator",
CodegenEvaluator(sizeForge, method, GetType(), classScope))
.SetProperty(
factory,
"SortCriteriaEvaluators",
CodegenEvaluators(sortCriteriaExpressions, method, GetType(), classScope))
.SetProperty(
factory,
"SortCriteriaTypes",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(sortCriteriaExpressions)))
.SetProperty(
factory,
"IsDescendingValues",
Constant(isDescendingValues))
.SetProperty(
factory,
"IsUseCollatorSort",
Constant(useCollatorSort))
.SetProperty(
factory,
"SortSerdes",
DataInputOutputSerdeForgeExtensions.CodegenArray(sortSerdes, method, classScope, null));
ViewMultiKeyHelper.Assign(criteriaExpressions, multiKeyClassNames, method, factory, symbols, classScope);
}
public ResultSetProcessorRowPerGroupForge(
EventType resultEventType,
EventType[] typesPerStream,
ExprNode[] groupKeyNodeExpressions,
ExprForge optionalHavingNode,
bool isSelectRStream,
bool isUnidirectional,
OutputLimitSpec outputLimitSpec,
bool isSorting,
bool isHistoricalOnly,
ResultSetProcessorOutputConditionType? outputConditionType,
EventType[] eventTypes,
OutputConditionPolledFactoryForge optionalOutputFirstConditionFactory,
MultiKeyClassRef multiKeyClassRef,
bool unboundedProcessor)
{
ResultEventType = resultEventType;
this.typesPerStream = typesPerStream;
GroupKeyNodeExpressions = groupKeyNodeExpressions;
OptionalHavingNode = optionalHavingNode;
IsSorting = isSorting;
IsSelectRStream = isSelectRStream;
IsUnidirectional = isUnidirectional;
OutputLimitSpec = outputLimitSpec;
IsHistoricalOnly = isHistoricalOnly;
OutputConditionType = outputConditionType;
EventTypes = eventTypes;
OptionalOutputFirstConditionFactory = optionalOutputFirstConditionFactory;
groupKeyTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupKeyNodeExpressions);
this.multiKeyClassRef = multiKeyClassRef;
this.unboundedProcessor = unboundedProcessor;
}
public void ProviderCodegen(
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
Type[] groupByTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupByNodes);
method.Block
.DeclareVar<AggregationServiceFactory>(
"svcFactory",
NewInstanceInner(classNames.ServiceFactory, Ref("this")))
.DeclareVar<AggregationRowFactory>(
"rowFactory",
NewInstanceInner(classNames.RowFactoryTop, Ref("this")))
.DeclareVar<DataInputOutputSerde<AggregationRow>>(
"rowSerde",
NewInstanceInner(classNames.RowSerdeTop, Ref("this")))
.MethodReturn(
ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.AGGREGATIONSERVICEFACTORYSERVICE)
.Add(
"GroupByRollup",
Ref("svcFactory"),
rollupDesc.Codegen(method, classScope),
Ref("rowFactory"),
rowStateForgeDesc.UseFlags.ToExpression(),
Ref("rowSerde"),
Constant(groupByTypes)));
}
public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ContextControllerDetailInitiatedTerminated), GetType(), classScope);
method.Block
.DeclareVar<ContextControllerDetailInitiatedTerminated>(
"detail",
NewInstance(typeof(ContextControllerDetailInitiatedTerminated)))
.SetProperty(Ref("detail"), "StartCondition", StartCondition.Make(method, symbols, classScope))
.SetProperty(Ref("detail"), "EndCondition", EndCondition.Make(method, symbols, classScope))
.SetProperty(Ref("detail"), "IsOverlapping", Constant(IsOverlapping));
if (DistinctExpressions != null && DistinctExpressions.Length > 0) {
method.Block
.SetProperty(
Ref("detail"),
"DistinctEval",
ExprNodeUtilityCodegen.CodegenEvaluatorMayMultiKeyWCoerce(
ExprNodeUtilityQuery.GetForges(DistinctExpressions),
null,
method,
GetType(),
classScope))
.SetProperty(
Ref("detail"),
"DistinctTypes",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(DistinctExpressions)));
}
method.Block.MethodReturn(Ref("detail"));
return LocalMethod(method);
}
public ResultSetProcessorAggregateGroupedForge(
EventType resultEventType,
ExprNode[] groupKeyNodeExpressions,
ExprForge optionalHavingNode,
bool isSelectRStream,
bool isUnidirectional,
OutputLimitSpec outputLimitSpec,
bool isSorting,
bool isHistoricalOnly,
ResultSetProcessorOutputConditionType? outputConditionType,
OutputConditionPolledFactoryForge optionalOutputFirstConditionFactory,
EventType[] eventTypes,
MultiKeyClassRef multiKeyClassRef)
{
ResultEventType = resultEventType;
GroupKeyNodeExpressions = groupKeyNodeExpressions;
OptionalHavingNode = optionalHavingNode;
IsSorting = isSorting;
IsSelectRStream = isSelectRStream;
IsUnidirectional = isUnidirectional;
OutputLimitSpec = outputLimitSpec;
IsHistoricalOnly = isHistoricalOnly;
OutputConditionType = outputConditionType;
OptionalOutputFirstConditionFactory = optionalOutputFirstConditionFactory;
EventTypes = eventTypes;
GroupKeyTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupKeyNodeExpressions);
MultiKeyClassRef = multiKeyClassRef;
}
public static MultiKeyPlan PlanMultiKey(
ExprForge[] criteriaExpressions,
bool lenientEquals,
StatementRawInfo raw,
SerdeCompileTimeResolver serdeResolver)
{
return(PlanMultiKey(ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions), lenientEquals, raw, serdeResolver));
}
public AggregatorAccessSortedImpl(
bool join,
AggregationStateSortedForge forge,
int col,
CodegenCtor ctor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter)
: base(optionalFilter)
{
this.forge = forge;
sorted = membersColumnized.AddMember(col, typeof(IOrderedDictionary <object, object>), "sorted");
size = membersColumnized.AddMember(col, typeof(int), "size");
var types = ExprNodeUtilityQuery.GetExprResultTypes(forge.Spec.Criteria);
comparator = classScope.AddOrGetDefaultFieldSharable(
new CodegenFieldSharableComparator(
COMPARATORHASHABLEMULTIKEYS,
types,
forge.Spec.IsSortUsingCollator,
forge.Spec.SortDescending));
ctor.Block.AssignRef(sorted, NewInstance <OrderedListDictionary <object, object> >(comparator));
sortedSerde = classScope.AddOrGetDefaultFieldSharable(
new ProxyCodegenFieldSharable()
{
ProcType = () => { return(typeof(DIOSerdeTreeMapEventsMayDeque)); },
ProcInitCtorScoped = () => {
var type = EventTypeUtility
.ResolveTypeCodegen(forge.Spec.StreamEventType, EPStatementInitServicesConstants.REF);
var criteriaSerdes = DataInputOutputSerdeForgeExtensions
.CodegenArray(forge.Spec.CriteriaSerdes, classScope.NamespaceScope.InitMethod, classScope, null);
return(ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.EVENTTYPERESOLVER)
.Add(EventTypeResolverConstants.GETEVENTSERDEFACTORY)
.Add("TreeMapEventsMayDeque", criteriaSerdes, type));
},
});
if (join)
{
joinRefs = membersColumnized.AddMember(col, typeof(RefCountedSetAtomicInteger <object>), "refs");
ctor.Block.AssignRef(joinRefs, NewInstance(typeof(RefCountedSetAtomicInteger <object>)));
joinRefsSerde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeEventTyped(
REFCOUNTEDSETATOMICINTEGER, forge.Spec.StreamEventType));
}
else
{
joinRefs = null;
joinRefsSerde = null;
}
}
public override ICollection<CodegenExpression> AdditionalParams(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var forges = QueryGraphValueEntryHashKeyedForge.GetForges(HashKeys);
var types = ExprNodeUtilityQuery.GetExprResultTypes(forges);
// we take coercion types from the index plan as the index plan is always accurate but not always available (for tables it is not)
Type[] coercionTypes;
var indexForge = _indexSpecs.Items.Get(IndexNum[0]);
if (indexForge != null) {
coercionTypes = indexForge.HashTypes;
}
else {
coercionTypes = _optionalCoercionTypes;
}
CodegenExpression getter;
EventType eventType = typesPerStream[LookupStream];
EventPropertyGetterSPI[] getterSPIS = QueryGraphValueEntryHashKeyedForge.GetGettersIfPropsOnly(_hashKeys);
if (indexForge != null) {
if (getterSPIS != null) {
getter = MultiKeyCodegen.CodegenGetterMayMultiKey(
eventType,
getterSPIS,
types,
coercionTypes,
indexForge.HashMultiKeyClasses,
method,
classScope);
}
else {
getter = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(forges, coercionTypes, indexForge.HashMultiKeyClasses, method, classScope);
}
}
else {
if (getterSPIS != null) {
getter = MultiKeyCodegen.CodegenGetterMayMultiKey(
eventType,
getterSPIS,
types,
coercionTypes,
_optionalEPLTableLookupMultiKey,
method,
classScope);
}
else {
getter = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(forges, coercionTypes, _optionalEPLTableLookupMultiKey, method, classScope);
}
}
return Collections.SingletonList(getter);
}
public CodegenExpression ToExpression(
string rowFactory,
string rowSerde,
CodegenExpression groupKeyEval)
{
return NewInstance<AggregationLocalGroupByLevel>(
NewInstance(rowFactory, Ref("this")),
NewInstance(rowSerde, Ref("this")),
Constant(ExprNodeUtilityQuery.GetExprResultTypes(PartitionForges)),
groupKeyEval,
Constant(IsDefaultLevel));
}
public AggregatorAccessSortedImpl(
bool join,
AggregationStateSortedForge forge,
int col,
CodegenCtor ctor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter)
: base(optionalFilter)
{
this.forge = forge;
sorted = membersColumnized.AddMember(col, typeof(OrderedDictionary<object,object>), "sorted");
size = membersColumnized.AddMember(col, typeof(int), "size");
var types = ExprNodeUtilityQuery.GetExprResultTypes(forge.Spec.Criteria);
comparator = classScope.AddOrGetDefaultFieldSharable(
new CodegenFieldSharableComparator(
COMPARATORHASHABLEMULTIKEYS,
types,
forge.Spec.IsSortUsingCollator,
forge.Spec.SortDescending));
ctor.Block.AssignRef(sorted, NewInstance(typeof(OrderedDictionary<object, object>), comparator));
sortedSerde = classScope.AddOrGetDefaultFieldSharable(
new ProxyCodegenFieldSharable {
ProcType = () => { return typeof(DIOSerdeTreeMapEventsMayDeque); },
ProcInitCtorScoped = () => {
var type = EventTypeUtility.ResolveTypeCodegen(
forge.Spec.StreamEventType,
EPStatementInitServicesConstants.REF);
return ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.DATAINPUTOUTPUTSERDEPROVIDER)
.Add(
"TreeMapEventsMayDeque",
Constant(forge.Spec.CriteriaTypes),
type);
}
});
if (join) {
joinRefs = membersColumnized.AddMember(col, typeof(RefCountedSetAtomicInteger<object>), "refs");
ctor.Block.AssignRef(joinRefs, NewInstance(typeof(RefCountedSetAtomicInteger<object>)));
joinRefsSerde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeEventTyped(REFCOUNTEDSETATOMICINTEGER, forge.Spec.StreamEventType));
}
else {
joinRefs = null;
joinRefsSerde = null;
}
}
private AggregationForgeFactoryAccessSorted HandleCreateTable(ExprValidationContext validationContext)
{
if (positionalParams.Length == 0) {
throw new ExprValidationException("Missing the sort criteria expression");
}
var message = "For tables columns, the aggregation function requires the 'sorted(*)' declaration";
if (!sortedwin && !ever) {
throw new ExprValidationException(message);
}
if (validationContext.StreamTypeService.StreamNames.Length == 0) {
throw new ExprValidationException("'Sorted' requires that the event type is provided");
}
var containedType = validationContext.StreamTypeService.EventTypes[0];
var componentType = containedType.UnderlyingType;
var criteriaExpressions = CriteriaExpressions;
var accessorResultType = componentType;
AggregationAccessorForge accessor;
if (!sortedwin) {
accessor = new AggregationAccessorMinMaxByNonTable(IsMax);
}
else {
accessor = new AggregationAccessorSortedNonTable(IsMax, componentType);
accessorResultType = TypeHelper.GetArrayType(accessorResultType);
}
var criteriaTypes = ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions.First);
var stateDesc = new SortedAggregationStateDesc(
IsMax,
validationContext.ImportService,
criteriaExpressions.First,
criteriaTypes,
criteriaExpressions.Second,
ever,
0,
this,
null,
containedType);
return new AggregationForgeFactoryAccessSorted(
this,
accessor,
accessorResultType,
containedType,
null,
stateDesc,
null);
}
public static void Assign(
ExprNode[] criteriaExpressions,
MultiKeyClassRef multiKeyClassNames,
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpression criteriaEval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(criteriaExpressions, null, multiKeyClassNames, method, classScope);
method.Block
.SetProperty(factory, "CriteriaEval", criteriaEval)
.SetProperty(factory, "CriteriaTypes", Constant(ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions)))
.SetProperty(factory, "KeySerde", multiKeyClassNames.GetExprMKSerde(method, classScope));
}
protected void ValidateGroupKeys(
TableMetaData metadata,
ExprValidationContext validationContext)
{
if (ChildNodes.Length > 0) {
groupKeyEvaluators = ExprNodeUtilityQuery.GetForges(ChildNodes);
}
else {
groupKeyEvaluators = new ExprForge[0];
}
var typesReturned = ExprNodeUtilityQuery.GetExprResultTypes(ChildNodes);
var keyTypes = metadata.IsKeyed ? metadata.KeyTypes : new Type[0];
ExprTableNodeUtil.ValidateExpressions(TableName, typesReturned, "key", ChildNodes, keyTypes, "key");
}
public CodegenExpression ToExpression(
string rowFactory,
string rowSerde,
CodegenExpression groupKeyEval,
CodegenMethod method,
CodegenClassScope classScope)
{
return NewInstance<AggregationLocalGroupByLevel>(
NewInstanceInner(rowFactory, Ref("this")),
NewInstanceInner(rowSerde, Ref("this")),
Constant(ExprNodeUtilityQuery.GetExprResultTypes(PartitionForges)),
groupKeyEval,
Constant(IsDefaultLevel),
PartitionMKClasses.GetExprMKSerde(method, classScope));
}
public CodegenExpression Make(
CodegenMethodScope parentInitMethod,
CodegenClassScope classScope)
{
var method = parentInitMethod.MakeChild(typeof(ScriptDescriptorRuntime), GetType(), classScope)
.AddParam(
typeof(EPStatementInitServices),
EPStatementInitServicesConstants.REF.Ref);
method.Block
.DeclareVar<ScriptDescriptorRuntime>("sd", NewInstance(typeof(ScriptDescriptorRuntime)))
.SetProperty(Ref("sd"), "OptionalDialect", Constant(OptionalDialect))
.SetProperty(Ref("sd"), "ScriptName", Constant(ScriptName))
.SetProperty(Ref("sd"), "Expression", Constant(Expression))
.SetProperty(Ref("sd"), "ParameterNames", Constant(ParameterNames))
.SetProperty(
Ref("sd"),
"EvaluationTypes",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(Parameters)))
.SetProperty(
Ref("sd"),
"Parameters",
ExprNodeUtilityCodegen.CodegenEvaluators(Parameters, method, GetType(), classScope))
.SetProperty(Ref("sd"), "DefaultDialect", Constant(_defaultDialect))
.SetProperty(
Ref("sd"),
"ImportService",
ExprDotName(
EPStatementInitServicesConstants.REF,
EPStatementInitServicesConstants.IMPORTSERVICERUNTIME))
.SetProperty(
Ref("sd"),
"ScriptCompiler",
ExprDotName(
EPStatementInitServicesConstants.REF,
EPStatementInitServicesConstants.SCRIPTCOMPILER))
.SetProperty(
Ref("sd"),
"Coercer",
ReturnType.IsNumeric()
? StaticMethod(
typeof(SimpleNumberCoercerFactory),
"GetCoercer",
Constant(typeof(object)),
Constant(ReturnType.GetBoxedType()))
: ConstantNull())
.MethodReturn(Ref("sd"));
return LocalMethod(method, EPStatementInitServicesConstants.REF);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(TypeOfPlanFactory(), GetType(), classScope);
IList<CodegenExpression> @params = new List<CodegenExpression>(6);
@params.Add(Constant(lookupStream));
@params.Add(Constant(indexedStream));
@params.Add(
CodegenMakeableUtil.MakeArray(
"reqIdxKeys",
typeof(TableLookupIndexReqKey),
IndexNum,
GetType(),
method,
symbols,
classScope));
@params.AddAll(AdditionalParams(method, symbols, classScope));
method.Block
.DeclareVar(TypeOfPlanFactory(), "plan", NewInstance(TypeOfPlanFactory(), @params.ToArray()));
// inject additional information for virtual data windows
if (indexedStreamIsVDW) {
var keyDesc = KeyDescriptor;
var hashes = keyDesc.HashExpressions;
var ranges = keyDesc.Ranges.ToArray();
var rangeResults = QueryGraphValueEntryRangeForge.GetRangeResultTypes(ranges);
method.Block
.SetProperty(
Ref("plan"),
"VirtualDWHashEvals",
ExprNodeUtilityCodegen.CodegenEvaluators(hashes, method, GetType(), classScope))
.SetProperty(
Ref("plan"),
"VirtualDWHashTypes",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(hashes)))
.SetProperty(
Ref("plan"),
"VirtualDWRangeEvals",
QueryGraphValueEntryRangeForge.MakeArray(ranges, method, symbols, classScope))
.SetProperty(Ref("plan"), "VirtualDWRangeTypes", Constant(rangeResults));
}
method.Block.MethodReturn(Ref("plan"));
return LocalMethod(method);
}
public void ProviderCodegen(
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
var groupByTypes = ExprNodeUtilityQuery.GetExprResultTypes(aggGroupByDesc.GroupByNodes);
if (aggGroupByDesc.IsReclaimAged) {
reclaimAge = aggGroupByDesc.ReclaimEvaluationFunctionMaxAge.Make(classScope);
reclaimFreq = aggGroupByDesc.ReclaimEvaluationFunctionFrequency.Make(classScope);
}
else {
reclaimAge = ConstantNull();
reclaimFreq = ConstantNull();
}
var stmtFields = ResultSetProcessorCodegenNames.REF_STATEMENT_FIELDS;
var timeAbacus = classScope.AddOrGetDefaultFieldSharable(TimeAbacusField.INSTANCE);
method.Block
.DeclareVar<AggregationRowFactory>(
"rowFactory",
NewInstanceInner(classNames.RowFactoryTop, Ref("this")))
.DeclareVar<DataInputOutputSerde<AggregationRow>>(
"rowSerde",
NewInstanceInner(classNames.RowSerdeTop, Ref("this")))
.DeclareVar<AggregationServiceFactory>(
"svcFactory",
NewInstanceInner(classNames.ServiceFactory, Ref("this")))
.DeclareVar<DataInputOutputSerde>(
"serde", aggGroupByDesc.GroupByMultiKey.GetExprMKSerde(method, classScope))
.MethodReturn(
ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.AGGREGATIONSERVICEFACTORYSERVICE)
.Add(
"GroupBy",
Ref("svcFactory"),
Ref("rowFactory"),
aggGroupByDesc.RowStateForgeDescs.UseFlags.ToExpression(),
Ref("rowSerde"),
Constant(groupByTypes),
reclaimAge,
reclaimFreq,
timeAbacus,
Ref("serde")));
}
private static CodegenFieldSharable GetComparator(
OrderByElementForge[] orderBy,
bool isSortUsingCollator)
{
var nodes = new ExprNode[orderBy.Length];
var descending = new bool[orderBy.Length];
for (var i = 0; i < orderBy.Length; i++) {
nodes[i] = orderBy[i].ExprNode;
descending[i] = orderBy[i].IsDescending();
}
var types = ExprNodeUtilityQuery.GetExprResultTypes(nodes);
return new CodegenFieldSharableComparator(
COMPARATORHASHABLEMULTIKEYS,
types,
isSortUsingCollator,
descending);
}
public override void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
eventType = parentEventType;
var message =
NAME + " window requires a numeric size parameter and a list of expressions providing sort keys";
if (viewParameters.Count < 2) {
throw new ViewParameterException(message);
}
var validated = ViewForgeSupport.Validate(
NAME + " window",
parentEventType,
viewParameters,
true,
viewForgeEnv,
streamNumber);
for (var i = 1; i < validated.Length; i++) {
ViewForgeSupport.AssertReturnsNonConstant(NAME + " window", validated[i], i);
}
ViewForgeSupport.ValidateNoProperties(ViewName, validated[0], 0);
sizeForge = ViewForgeSupport.ValidateSizeParam(ViewName, validated[0], 0);
sortCriteriaExpressions = new ExprNode[validated.Length - 1];
isDescendingValues = new bool[sortCriteriaExpressions.Length];
for (var i = 1; i < validated.Length; i++) {
if (validated[i] is ExprOrderedExpr) {
isDescendingValues[i - 1] = ((ExprOrderedExpr) validated[i]).IsDescending;
sortCriteriaExpressions[i - 1] = validated[i].ChildNodes[0];
}
else {
sortCriteriaExpressions[i - 1] = validated[i];
}
}
sortSerdes = viewForgeEnv.SerdeResolver.SerdeForDataWindowSortCriteria(
ExprNodeUtilityQuery.GetExprResultTypes(sortCriteriaExpressions),
viewForgeEnv.StatementRawInfo);
}
public ResultSetProcessorRowPerGroupRollupForge(
EventType resultEventType,
GroupByRollupPerLevelForge perLevelForges,
ExprNode[] groupKeyNodeExpressions,
bool isSelectRStream,
bool isUnidirectional,
OutputLimitSpec outputLimitSpec,
bool isSorting,
bool noDataWindowSingleStream,
AggregationGroupByRollupDescForge groupByRollupDesc,
bool isJoin,
bool isHistoricalOnly,
bool iterateUnbounded,
ResultSetProcessorOutputConditionType? outputConditionType,
OutputConditionPolledFactoryForge optionalOutputFirstConditionFactory,
EventType[] eventTypes,
MultiKeyClassRef multiKeyClassRef)
{
ResultEventType = resultEventType;
GroupKeyNodeExpressions = groupKeyNodeExpressions;
PerLevelForges = perLevelForges;
IsSorting = isSorting;
IsSelectRStream = isSelectRStream;
IsUnidirectional = isUnidirectional;
OutputLimitSpec = outputLimitSpec;
var noDataWindowSingleSnapshot = iterateUnbounded ||
outputLimitSpec != null &&
outputLimitSpec.DisplayLimit == OutputLimitLimitType.SNAPSHOT &&
noDataWindowSingleStream;
unbounded = noDataWindowSingleSnapshot && !isHistoricalOnly;
GroupByRollupDesc = groupByRollupDesc;
IsJoin = isJoin;
IsHistoricalOnly = isHistoricalOnly;
OutputConditionType = outputConditionType;
OptionalOutputFirstConditionFactory = optionalOutputFirstConditionFactory;
EventTypes = eventTypes;
GroupKeyTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupKeyNodeExpressions);
MultiKeyClassRef = multiKeyClassRef;
}
public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ContextControllerDetailInitiatedTerminated), GetType(), classScope);
var distinctEval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(
DistinctExpressions, null, DistinctMultiKey, method, classScope);
method.Block
.DeclareVar<ContextControllerDetailInitiatedTerminated>(
"detail",
NewInstance(typeof(ContextControllerDetailInitiatedTerminated)))
.SetProperty(Ref("detail"), "StartCondition", StartCondition.Make(method, symbols, classScope))
.SetProperty(Ref("detail"), "EndCondition", EndCondition.Make(method, symbols, classScope))
.SetProperty(Ref("detail"), "IsOverlapping", Constant(IsOverlapping))
.SetProperty(Ref("detail"), "DistinctEval", distinctEval)
.SetProperty(Ref("detail"), "DistinctTypes", DistinctExpressions == null ? ConstantNull() : Constant(ExprNodeUtilityQuery.GetExprResultTypes(DistinctExpressions)))
.SetProperty(Ref("detail"), "DistinctSerde", DistinctMultiKey == null ? ConstantNull() : DistinctMultiKey.GetExprMKSerde(method, classScope));
method.Block.MethodReturn(Ref("detail"));
return LocalMethod(method);
}
private AggregationForgeFactoryAccessSorted HandleCreateTable(ExprValidationContext validationContext)
{
if (positionalParams.Length == 0)
{
throw new ExprValidationException("Missing the sort criteria expression");
}
string message = "For tables columns, the aggregation function requires the 'sorted(*)' declaration";
if (!_sortedwin && !_ever)
{
throw new ExprValidationException(message);
}
if (validationContext.StreamTypeService.StreamNames.Length == 0)
{
throw new ExprValidationException("'Sorted' requires that the event type is provided");
}
EventType containedType = validationContext.StreamTypeService.EventTypes[0];
Type componentType = containedType.UnderlyingType;
Pair <ExprNode[], bool[]> criteriaExpressions = CriteriaExpressions;
Type accessorResultType = componentType;
AggregationAccessorForge accessor;
if (!_sortedwin)
{
accessor = new AggregationAccessorMinMaxByNonTable(_max);
}
else
{
accessor = new AggregationAccessorSortedNonTable(_max, componentType);
accessorResultType = TypeHelper.GetArrayType(accessorResultType);
}
Type[] criteriaTypes = ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions.First);
DataInputOutputSerdeForge[] criteriaSerdes = new DataInputOutputSerdeForge[criteriaTypes.Length];
for (int i = 0; i < criteriaTypes.Length; i++)
{
criteriaSerdes[i] = validationContext.SerdeResolver.SerdeForAggregation(criteriaTypes[i], validationContext.StatementRawInfo);
}
SortedAggregationStateDesc stateDesc = new SortedAggregationStateDesc(
_max,
validationContext.ImportService,
criteriaExpressions.First,
criteriaTypes,
criteriaSerdes,
criteriaExpressions.Second,
_ever,
0,
this,
null,
containedType);
IList <StmtClassForgeableFactory> serdeForgables = SerdeEventTypeUtility.Plan(
containedType,
validationContext.StatementRawInfo,
validationContext.SerdeEventTypeRegistry,
validationContext.SerdeResolver);
validationContext.AdditionalForgeables.AddAll(serdeForgables);
return(new AggregationForgeFactoryAccessSorted(this, accessor, accessorResultType, containedType, null, stateDesc, null));
}
private AggregationForgeFactoryAccessSorted HandleNonTable(ExprValidationContext validationContext)
{
if (positionalParams.Length == 0) {
throw new ExprValidationException("Missing the sort criteria expression");
}
// validate that the streams referenced in the criteria are a single stream's
var streams = ExprNodeUtilityQuery.GetIdentStreamNumbers(positionalParams[0]);
if (streams.Count > 1 || streams.IsEmpty()) {
throw new ExprValidationException(
ErrorPrefix + " requires that any parameter expressions evaluate properties of the same stream");
}
var streamNum = streams.First();
// validate that there is a remove stream, use "ever" if not
if (!ever &&
ExprAggMultiFunctionLinearAccessNode.GetIstreamOnly(
validationContext.StreamTypeService,
streamNum)) {
if (sortedwin) {
throw new ExprValidationException(
ErrorPrefix + " requires that a data window is declared for the stream");
}
}
// determine typing and evaluation
containedType = validationContext.StreamTypeService.EventTypes[streamNum];
var componentType = containedType.UnderlyingType;
var accessorResultType = componentType;
AggregationAccessorForge accessor;
var tableMetadata = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(containedType);
if (!sortedwin) {
if (tableMetadata != null) {
accessor = new AggregationAccessorMinMaxByTable(IsMax, tableMetadata);
}
else {
accessor = new AggregationAccessorMinMaxByNonTable(IsMax);
}
}
else {
if (tableMetadata != null) {
accessor = new AggregationAccessorSortedTable(IsMax, componentType, tableMetadata);
}
else {
accessor = new AggregationAccessorSortedNonTable(IsMax, componentType);
}
accessorResultType = TypeHelper.GetArrayType(accessorResultType);
}
var criteriaExpressions = CriteriaExpressions;
AggregationStateTypeWStream type;
if (ever) {
type = IsMax ? AggregationStateTypeWStream.MAXEVER : AggregationStateTypeWStream.MINEVER;
}
else {
type = AggregationStateTypeWStream.SORTED;
}
var stateKey = new AggregationStateKeyWStream(
streamNum,
containedType,
type,
criteriaExpressions.First,
optionalFilter);
var optionalFilterForge = optionalFilter == null ? null : optionalFilter.Forge;
var streamEventType = validationContext.StreamTypeService.EventTypes[streamNum];
var criteriaTypes = ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions.First);
var sortedDesc = new
SortedAggregationStateDesc(
IsMax,
validationContext.ImportService,
criteriaExpressions.First,
criteriaTypes,
criteriaExpressions.Second,
ever,
streamNum,
this,
optionalFilterForge,
streamEventType);
return new AggregationForgeFactoryAccessSorted(
this,
accessor,
accessorResultType,
containedType,
stateKey,
sortedDesc,
AggregationAgentDefault.INSTANCE);
}
private AggregationForgeFactoryAccessSorted HandleNonTable(ExprValidationContext validationContext)
{
if (positionalParams.Length == 0)
{
throw new ExprValidationException("Missing the sort criteria expression");
}
// validate that the streams referenced in the criteria are a single stream's
ISet <int> streams = ExprNodeUtilityQuery.GetIdentStreamNumbers(positionalParams[0]);
if (streams.Count > 1 || streams.IsEmpty())
{
throw new ExprValidationException(ErrorPrefix + " requires that any parameter expressions evaluate properties of the same stream");
}
int streamNum = streams.First();
// validate that there is a remove stream, use "ever" if not
if (!_ever && ExprAggMultiFunctionLinearAccessNode.GetIstreamOnly(validationContext.StreamTypeService, streamNum))
{
if (_sortedwin)
{
throw new ExprValidationException(ErrorPrefix + " requires that a data window is declared for the stream");
}
}
// determine typing and evaluation
_containedType = validationContext.StreamTypeService.EventTypes[streamNum];
Type componentType = _containedType.UnderlyingType;
Type accessorResultType = componentType;
AggregationAccessorForge accessor;
TableMetaData tableMetadata = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(_containedType);
if (!_sortedwin)
{
if (tableMetadata != null)
{
accessor = new AggregationAccessorMinMaxByTable(_max, tableMetadata);
}
else
{
accessor = new AggregationAccessorMinMaxByNonTable(_max);
}
}
else
{
if (tableMetadata != null)
{
accessor = new AggregationAccessorSortedTable(_max, componentType, tableMetadata);
}
else
{
accessor = new AggregationAccessorSortedNonTable(_max, componentType);
}
accessorResultType = TypeHelper.GetArrayType(accessorResultType);
}
Pair <ExprNode[], bool[]> criteriaExpressions = CriteriaExpressions;
AggregationStateTypeWStream type;
if (_ever)
{
type = _max ? AggregationStateTypeWStream.MAXEVER : AggregationStateTypeWStream.MINEVER;
}
else
{
type = AggregationStateTypeWStream.SORTED;
}
AggregationStateKeyWStream stateKey = new AggregationStateKeyWStream(streamNum, _containedType, type, criteriaExpressions.First, optionalFilter);
ExprForge optionalFilterForge = optionalFilter == null ? null : optionalFilter.Forge;
EventType streamEventType = validationContext.StreamTypeService.EventTypes[streamNum];
Type[] criteriaTypes = ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions.First);
DataInputOutputSerdeForge[] criteriaSerdes = new DataInputOutputSerdeForge[criteriaTypes.Length];
for (int i = 0; i < criteriaTypes.Length; i++)
{
criteriaSerdes[i] = validationContext.SerdeResolver.SerdeForAggregation(criteriaTypes[i], validationContext.StatementRawInfo);
}
SortedAggregationStateDesc sortedDesc = new
SortedAggregationStateDesc(
_max,
validationContext.ImportService,
criteriaExpressions.First,
criteriaTypes,
criteriaSerdes,
criteriaExpressions.Second,
_ever,
streamNum,
this,
optionalFilterForge,
streamEventType);
IList <StmtClassForgeableFactory> serdeForgables = SerdeEventTypeUtility.Plan(
_containedType,
validationContext.StatementRawInfo,
validationContext.SerdeEventTypeRegistry,
validationContext.SerdeResolver);
validationContext.AdditionalForgeables.AddAll(serdeForgables);
return(new AggregationForgeFactoryAccessSorted(
this,
accessor,
accessorResultType,
_containedType,
stateKey,
sortedDesc,
AggregationAgentDefault.INSTANCE));
}
public static AggregationServiceForgeDesc GetService(
IList<ExprAggregateNode> selectAggregateExprNodes,
IDictionary<ExprNode, string> selectClauseNamedNodes,
IList<ExprDeclaredNode> declaredExpressions,
ExprNode[] groupByNodes,
MultiKeyClassRef groupByMultiKey,
IList<ExprAggregateNode> havingAggregateExprNodes,
IList<ExprAggregateNode> orderByAggregateExprNodes,
IList<ExprAggregateNodeGroupKey> groupKeyExpressions,
bool hasGroupByClause,
Attribute[] annotations,
VariableCompileTimeResolver variableCompileTimeResolver,
bool isDisallowNoReclaim,
ExprNode whereClause,
ExprNode havingClause,
EventType[] typesPerStream,
AggregationGroupByRollupDescForge groupByRollupDesc,
string optionalContextName,
IntoTableSpec intoTableSpec,
TableCompileTimeResolver tableCompileTimeResolver,
bool isUnidirectional,
bool isFireAndForget,
bool isOnSelect,
ImportServiceCompileTime importService,
StatementRawInfo raw,
SerdeCompileTimeResolver serdeResolver)
{
// No aggregates used, we do not need this service
if (selectAggregateExprNodes.IsEmpty() && havingAggregateExprNodes.IsEmpty()) {
if (intoTableSpec != null) {
throw new ExprValidationException("Into-table requires at least one aggregation function");
}
return new AggregationServiceForgeDesc(
AggregationServiceNullFactory.INSTANCE,
EmptyList<AggregationServiceAggExpressionDesc>.Instance,
EmptyList<ExprAggregateNodeGroupKey>.Instance,
EmptyList<StmtClassForgeableFactory>.Instance);
}
// Validate the absence of "prev" function in where-clause:
// Since the "previous" function does not post remove stream results, disallow when used with aggregations.
if (whereClause != null || havingClause != null) {
var visitor = new ExprNodePreviousVisitorWParent();
whereClause?.Accept(visitor);
havingClause?.Accept(visitor);
if (visitor.Previous != null && !visitor.Previous.IsEmpty()) {
string funcname = visitor.Previous[0]
.Second.PreviousType.ToString()
.ToLowerInvariant();
throw new ExprValidationException(
"The '" +
funcname +
"' function may not occur in the where-clause or having-clause of a statement with aggregations as 'previous' does not provide remove stream data; Use the 'first','last','window' or 'count' aggregation functions instead");
}
}
// Compile a map of aggregation nodes and equivalent-to aggregation nodes.
// Equivalent-to functions are for example "select sum(a*b), 5*sum(a*b)".
// Reducing the total number of aggregation functions.
var aggregations = new List<AggregationServiceAggExpressionDesc>();
var intoTableNonRollup = groupByRollupDesc == null && intoTableSpec != null;
foreach (var selectAggNode in selectAggregateExprNodes) {
AddEquivalent(selectAggNode, aggregations, intoTableNonRollup);
}
foreach (var havingAggNode in havingAggregateExprNodes) {
AddEquivalent(havingAggNode, aggregations, intoTableNonRollup);
}
foreach (var orderByAggNode in orderByAggregateExprNodes) {
AddEquivalent(orderByAggNode, aggregations, intoTableNonRollup);
}
// Construct a list of evaluation node for the aggregation functions (regular agg).
// For example "sum(2 * 3)" would make the sum an evaluation node.
IList<ExprForge[]> methodAggForgesList = new List<ExprForge[]>();
foreach (var aggregation in aggregations) {
var aggregateNode = aggregation.AggregationNode;
if (!aggregateNode.Factory.IsAccessAggregation) {
var forges = aggregateNode.Factory.GetMethodAggregationForge(
typesPerStream.Length > 1,
typesPerStream);
methodAggForgesList.Add(forges);
}
}
// determine local group-by, report when hook provided
var localGroupDesc = AnalyzeLocalGroupBy(aggregations, groupByNodes, groupByRollupDesc, intoTableSpec);
// determine binding
if (intoTableSpec != null) {
// obtain metadata
var metadata = tableCompileTimeResolver.Resolve(intoTableSpec.Name);
if (metadata == null) {
throw new ExprValidationException(
"Invalid into-table clause: Failed to find table by name '" + intoTableSpec.Name + "'");
}
EPLValidationUtil.ValidateContextName(
true,
intoTableSpec.Name,
metadata.OptionalContextName,
optionalContextName,
false);
// validate group keys
var groupByTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupByNodes);
var keyTypes = metadata.IsKeyed ? metadata.KeyTypes : new Type[0];
ExprTableNodeUtil.ValidateExpressions(
intoTableSpec.Name,
groupByTypes,
"group-by",
groupByNodes,
keyTypes,
"group-by");
// determine how this binds to existing aggregations, assign column numbers
var bindingMatchResult = MatchBindingsAssignColumnNumbers(
intoTableSpec,
metadata,
aggregations,
selectClauseNamedNodes,
methodAggForgesList,
declaredExpressions,
importService,
raw.StatementName);
// return factory
AggregationServiceFactoryForge serviceForgeX = new AggregationServiceFactoryForgeTable(
metadata,
bindingMatchResult.MethodPairs,
bindingMatchResult.TargetStates,
bindingMatchResult.Agents,
groupByRollupDesc);
return new AggregationServiceForgeDesc(serviceForgeX, aggregations, groupKeyExpressions, EmptyList<StmtClassForgeableFactory>.Instance);
}
// Assign a column number to each aggregation node. The regular aggregation goes first followed by access-aggregation.
var columnNumber = 0;
foreach (var entry in aggregations) {
if (!entry.Factory.IsAccessAggregation) {
entry.SetColumnNum(columnNumber++);
}
}
foreach (var entry in aggregations) {
if (entry.Factory.IsAccessAggregation) {
entry.SetColumnNum(columnNumber++);
}
}
// determine method aggregation factories and evaluators(non-access)
var methodAggForges = methodAggForgesList.ToArray();
var methodAggFactories = new AggregationForgeFactory[methodAggForges.Length];
var count = 0;
foreach (var aggregation in aggregations) {
var aggregateNode = aggregation.AggregationNode;
if (!aggregateNode.Factory.IsAccessAggregation) {
methodAggFactories[count] = aggregateNode.Factory;
count++;
}
}
// handle access aggregations
var multiFunctionAggPlan = AggregationMultiFunctionAnalysisHelper.AnalyzeAccessAggregations(
aggregations,
importService,
isFireAndForget,
raw.StatementName,
groupByNodes);
var accessorPairsForge = multiFunctionAggPlan.AccessorPairsForge;
var accessFactories = multiFunctionAggPlan.StateFactoryForges;
var hasAccessAgg = accessorPairsForge.Length > 0;
var hasMethodAgg = methodAggFactories.Length > 0;
AggregationServiceFactoryForge serviceForge;
var useFlags = new AggregationUseFlags(isUnidirectional, isFireAndForget, isOnSelect);
var additionalForgeables = new List<StmtClassForgeableFactory>();
// analyze local group by
AggregationLocalGroupByPlanForge localGroupByPlan = null;
if (localGroupDesc != null) {
AggregationLocalGroupByPlanDesc plan = AggregationGroupByLocalGroupByAnalyzer.Analyze(
methodAggForges,
methodAggFactories,
accessFactories,
localGroupDesc,
groupByNodes,
groupByMultiKey,
accessorPairsForge,
raw,
serdeResolver);
localGroupByPlan = plan.Forge;
additionalForgeables.AddAll(plan.AdditionalForgeables);
try {
var hook = (AggregationLocalLevelHook) ImportUtil.GetAnnotationHook(
annotations,
HookType.INTERNAL_AGGLOCALLEVEL,
typeof(AggregationLocalLevelHook),
importService);
hook?.Planned(localGroupDesc, localGroupByPlan);
}
catch (ExprValidationException) {
throw new EPException("Failed to obtain hook for " + HookType.INTERNAL_AGGLOCALLEVEL);
}
}
// Handle without a group-by clause: we group all into the same pot
var rowStateDesc = new AggregationRowStateForgeDesc(
hasMethodAgg ? methodAggFactories : null,
hasMethodAgg ? methodAggForges : null,
hasAccessAgg ? accessFactories : null,
hasAccessAgg ? accessorPairsForge : null,
useFlags);
if (!hasGroupByClause) {
if (localGroupByPlan != null) {
serviceForge = new AggSvcLocalGroupByForge(false, localGroupByPlan, useFlags);
}
else {
serviceForge = new AggregationServiceGroupAllForge(rowStateDesc);
}
}
else {
var groupDesc = new AggGroupByDesc(
rowStateDesc,
isUnidirectional,
isFireAndForget,
isOnSelect,
groupByNodes,
groupByMultiKey);
var hasNoReclaim = HintEnum.DISABLE_RECLAIM_GROUP.GetHint(annotations) != null;
var reclaimGroupAged = HintEnum.RECLAIM_GROUP_AGED.GetHint(annotations);
var reclaimGroupFrequency = HintEnum.RECLAIM_GROUP_AGED.GetHint(annotations);
if (localGroupByPlan != null) {
serviceForge = new AggSvcLocalGroupByForge(true, localGroupByPlan, useFlags);
}
else {
if (!isDisallowNoReclaim && hasNoReclaim) {
if (groupByRollupDesc != null) {
throw GetRollupReclaimEx();
}
serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus);
}
else if (!isDisallowNoReclaim && reclaimGroupAged != null) {
if (groupByRollupDesc != null) {
throw GetRollupReclaimEx();
}
CompileReclaim(
groupDesc,
reclaimGroupAged,
reclaimGroupFrequency,
variableCompileTimeResolver,
optionalContextName);
serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus);
}
else if (groupByRollupDesc != null) {
serviceForge = new AggSvcGroupByRollupForge(rowStateDesc, groupByRollupDesc, groupByNodes);
}
else {
groupDesc.IsRefcounted = true;
serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus);
}
}
}
return new AggregationServiceForgeDesc(serviceForge, aggregations, groupKeyExpressions, additionalForgeables);
}
public override IList<StmtClassForgeableFactory> Validate(
StreamTypeService typeService,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
// validate and visit
var validationContext = new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
var visitor = new ExprNodeIdentifierAndStreamRefVisitor(true);
var validatedInputParameters = new List<ExprNode>();
foreach (var exprNode in methodStreamSpec.Expressions) {
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.METHODINVJOIN,
exprNode,
validationContext);
validatedInputParameters.Add(validated);
validated.Accept(visitor);
}
// determine required streams
foreach (ExprNodePropOrStreamDesc @ref in visitor.Refs) {
SubordinateStreams.Add(@ref.StreamNum);
}
// class-based evaluation
MethodInfo targetMethod = null;
if (metadata.MethodProviderClass != null) {
// resolve actual method to use
ExprNodeUtilResolveExceptionHandler handler = new ProxyExprNodeUtilResolveExceptionHandler {
ProcHandle = e => {
if (methodStreamSpec.Expressions.Count == 0) {
return new ExprValidationException(
"Method footprint does not match the number or type of expression parameters, expecting no parameters in method: " +
e.Message);
}
var resultTypes = ExprNodeUtilityQuery.GetExprResultTypes(validatedInputParameters);
return new ExprValidationException(
"Method footprint does not match the number or type of expression parameters, expecting a method where parameters are typed '" +
TypeHelper.GetParameterAsString(resultTypes) +
"': " +
e.Message);
}
};
var desc = ExprNodeUtilityResolve.ResolveMethodAllowWildcardAndStream(
metadata.MethodProviderClass.FullName,
metadata.IsStaticMethod ? null : metadata.MethodProviderClass,
methodStreamSpec.MethodName,
validatedInputParameters,
false,
null,
handler,
methodStreamSpec.MethodName,
@base.StatementRawInfo,
services);
InputParamEvaluators = desc.ChildForges;
targetMethod = desc.ReflectionMethod;
}
else {
// script-based evaluation
InputParamEvaluators = ExprNodeUtilityQuery.GetForges(ExprNodeUtilityQuery.ToArray(validatedInputParameters));
}
// plan multikey
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(InputParamEvaluators, false, @base.StatementRawInfo, services.SerdeResolver);
MultiKeyClassRef = multiKeyPlan.ClassRef;
Pair<MethodTargetStrategyForge, MethodConversionStrategyForge> strategies =
PollExecStrategyPlanner.Plan(metadata, targetMethod, EventType);
target = strategies.First;
conversion = strategies.Second;
return multiKeyPlan.MultiKeyForgeables;
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(RowRecogDesc), GetType(), classScope);
var desc = Ref("desc");
CodegenExpression init = symbols.GetAddInitSvc(method);
var startStateNums = new int[_startStates.Length];
for (var i = 0; i < _startStates.Length; i++) {
startStateNums[i] = _startStates[i].NodeNumFlat;
}
var aggregationServiceFactories = ConstantNull();
if (_aggregationServices != null) {
var initAggsSvcs = new CodegenExpression[_aggregationServices.Length];
for (var i = 0; i < _aggregationServices.Length; i++) {
initAggsSvcs[i] = ConstantNull();
if (_aggregationServices[i] != null) {
var aggSvc = _aggregationServices[i];
var aggregationClassNames = new AggregationClassNames("_mra" + i);
var result = AggregationServiceFactoryCompiler.MakeInnerClassesAndInit(
false,
aggSvc.AggregationServiceFactoryForge,
method,
classScope,
classScope.OutermostClassName,
aggregationClassNames);
classScope.AddInnerClasses(result.InnerClasses);
initAggsSvcs[i] = LocalMethod(result.InitMethod, symbols.GetAddInitSvc(parent));
}
}
aggregationServiceFactories = NewArrayWithInit(typeof(AggregationServiceFactory), initAggsSvcs);
}
method.Block
.DeclareVar<RowRecogDesc>(desc.Ref, NewInstance(typeof(RowRecogDesc)))
.SetProperty(desc, "ParentEventType", EventTypeUtility.ResolveTypeCodegen(_parentEventType, init))
.SetProperty(desc, "RowEventType", EventTypeUtility.ResolveTypeCodegen(RowEventType, init))
.SetProperty(desc, "CompositeEventType", EventTypeUtility.ResolveTypeCodegen(_compositeEventType, init))
.SetProperty(
desc,
"MultimatchEventType",
_multimatchEventType == null
? ConstantNull()
: EventTypeUtility.ResolveTypeCodegen(_multimatchEventType, init))
.SetProperty(desc, "MultimatchStreamNumToVariable", Constant(_multimatchStreamNumToVariable))
.SetProperty(desc, "MultimatchVariableToStreamNum", Constant(_multimatchVariableToStreamNum))
.SetProperty(
desc,
"PartitionEvalMayNull",
MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(_partitionBy, null, _partitionByMultiKey, method, classScope))
.SetProperty(
desc,
"PartitionEvalTypes",
_partitionBy == null
? ConstantNull()
: Constant(ExprNodeUtilityQuery.GetExprResultTypes(_partitionBy)))
.SetProperty(desc, "PartitionEvalSerde", _partitionBy == null ? ConstantNull() : _partitionByMultiKey.GetExprMKSerde(method, classScope))
.SetProperty(desc, "VariableStreams", MakeVariableStreams(method, symbols, classScope))
.SetProperty(desc, "HasInterval", Constant(_hasInterval))
.SetProperty(desc, "IsIterateOnly", Constant(_iterateOnly))
.SetProperty(desc, "IsUnbound", Constant(_unbound))
.SetProperty(desc, "IsOrTerminated", Constant(_orTerminated))
.SetProperty(desc, "IsCollectMultimatches", Constant(_collectMultimatches))
.SetProperty(desc, "IsDefineAsksMultimatches", Constant(_defineAsksMultimatches))
.SetProperty(desc, "NumEventsEventsPerStreamDefine", Constant(_numEventsEventsPerStreamDefine))
.SetProperty(desc, "MultimatchVariablesArray", Constant(_multimatchVariablesArray))
.SetProperty(desc, "StatesOrdered", MakeStates(method, symbols, classScope))
.SetProperty(desc, "NextStatesPerState", MakeNextStates(method, classScope))
.SetProperty(desc, "StartStates", Constant(startStateNums))
.SetProperty(desc, "IsAllMatches", Constant(_allMatches))
.SetProperty(desc, "Skip", Constant(_skip))
.SetProperty(
desc,
"ColumnEvaluators",
ExprNodeUtilityCodegen.CodegenEvaluators(_columnEvaluators, method, GetType(), classScope))
.SetProperty(desc, "ColumnNames", Constant(_columnNames))
.SetProperty(
desc,
"IntervalCompute",
_intervalCompute == null ? ConstantNull() : _intervalCompute.MakeEvaluator(method, classScope))
.SetProperty(desc, "PreviousRandomAccessIndexes", Constant(_previousRandomAccessIndexes))
.SetProperty(desc, "AggregationServiceFactories", aggregationServiceFactories)
.SetProperty(
desc,
"AggregationResultFutureAssignables",
_aggregationServices == null ? ConstantNull() : MakeAggAssignables(method, classScope))
.MethodReturn(desc);
return LocalMethod(method);
}
public CodegenExpression EventBeanGetCodegen(
CodegenExpression beanExpression,
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var serializers = classScope.AddDefaultFieldUnshared(
true,
typeof(Serializer[]),
StaticMethod(
typeof(SerializerFactory),
"GetSerializers",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(nodes))));
CodegenMethod method = parent.MakeChild(typeof(object), this.GetType(), classScope)
.AddParam(typeof(EventBean), "eventBean");
method.Block
.DeclareVar<EventBean[]>("events", NewArrayWithInit(typeof(EventBean), Ref("eventBean")));
// method to return object-array from expressions
ExprForgeCodegenSymbol exprSymbol = new ExprForgeCodegenSymbol(true, null);
CodegenMethod exprMethod = method
.MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
CodegenExpression[] expressions = new CodegenExpression[nodes.Length];
for (int i = 0; i < nodes.Length; i++) {
expressions[i] = nodes[i]
.Forge.EvaluateCodegen(
nodes[i].Forge.EvaluationType,
exprMethod,
exprSymbol,
classScope);
}
exprSymbol.DerivedSymbolsCodegen(method, exprMethod.Block, classScope);
if (nodes.Length == 1) {
exprMethod.Block.MethodReturn(expressions[0]);
}
else {
exprMethod.Block.DeclareVar<object[]>(
"values",
NewArrayByLength(typeof(object), Constant(nodes.Length)));
for (int i = 0; i < nodes.Length; i++) {
CodegenExpression result = expressions[i];
exprMethod.Block.AssignArrayElement("values", Constant(i), result);
}
exprMethod.Block.MethodReturn(Ref("values"));
}
method.Block
.DeclareVar<object>(
"values",
LocalMethod(exprMethod, Ref("events"), ConstantTrue(), ConstantNull()))
.MethodReturn(
StaticMethod(
typeof(ContextControllerHashedGetterCRC32SerializedForge),
"SerializeAndCRC32Hash",
Ref("values"),
Constant(granularity),
serializers));
return LocalMethod(method, beanExpression);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (Script.ParameterNames.Length != Parameters.Count) {
throw new ExprValidationException(
string.Format(
"Invalid number of parameters for script '{0}', expected {1} parameters but received {2} parameters",
Script.Name,
Script.ParameterNames.Length,
Parameters.Count));
}
if (!validationContext.StatementCompileTimeService.Configuration.Compiler.Scripts.IsEnabled) {
throw new ExprValidationException("Script compilation has been disabled by configuration");
}
// validate all expression parameters
var validatedParameters = Parameters
.Select(
expr => ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.SCRIPTPARAMS,
expr,
validationContext))
.ToList();
// set up map of input parameter names and evaluators
var forges = new ExprForge[Script.ParameterNames.Length];
for (var i = 0; i < Script.ParameterNames.Length; i++) {
forges[i] = validatedParameters[i].Forge;
}
Parameters = validatedParameters;
// Compile script
var parameterTypes = ExprNodeUtilityQuery.GetExprResultTypes(forges);
var dialect = Script.OptionalDialect ?? _defaultDialect;
var compiled = CompileScript(
dialect,
Script.Name,
Script.Expression,
Script.ParameterNames,
parameterTypes,
Script.CompiledBuf,
validationContext.ImportService,
validationContext.ScriptCompiler);
// Determine declared return type
var declaredReturnType = GetDeclaredReturnType(Script.OptionalReturnTypeName, validationContext);
if (Script.IsOptionalReturnTypeIsArray && declaredReturnType != null) {
declaredReturnType = TypeHelper.GetArrayType(declaredReturnType);
}
Type returnType;
if (compiled.KnownReturnType == null && Script.OptionalReturnTypeName == null) {
returnType = typeof(object);
}
else if (compiled.KnownReturnType != null) {
if (declaredReturnType == null) {
returnType = compiled.KnownReturnType;
}
else {
var knownReturnType = compiled.KnownReturnType;
if (declaredReturnType.IsArray && knownReturnType.IsArray) {
// we are fine
}
else if (!knownReturnType.IsAssignmentCompatible(declaredReturnType)) {
throw new ExprValidationException(
"Return type and declared type not compatible for script '" +
Script.Name +
"', known return type is " +
knownReturnType.Name +
" versus declared return type " +
declaredReturnType.Name);
}
returnType = declaredReturnType;
}
}
else {
returnType = declaredReturnType;
}
if (returnType == null) {
returnType = typeof(object);
}
_eventTypeCollection = null;
if (Script.OptionalEventTypeName != null) {
if (returnType.IsArray && returnType.GetElementType() == typeof(EventBean)) {
_eventTypeCollection = EventTypeUtility.RequireEventType(
"Script",
Script.Name,
Script.OptionalEventTypeName,
validationContext.StatementCompileTimeService.EventTypeCompileTimeResolver);
}
else {
throw new ExprValidationException(EventTypeUtility.DisallowedAtTypeMessage());
}
}
_scriptDescriptor = new ScriptDescriptorCompileTime(
Script.OptionalDialect,
Script.Name,
Script.Expression,
Script.ParameterNames,
Parameters.ToArray(),
returnType,
_defaultDialect);
return null;
}
public override void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
eventType = parentEventType;
var message =
NAME +
" view requires a list of expressions providing unique keys, a numeric size parameter and a list of expressions providing sort keys";
if (viewParameters.Count < 3) {
throw new ViewParameterException(message);
}
// validate
var validated = ViewForgeSupport.Validate(
NAME,
parentEventType,
viewParameters,
true,
viewForgeEnv,
streamNumber);
// find size-parameter index
var indexNumericSize = -1;
for (var i = 0; i < validated.Length; i++) {
if (validated[i] is ExprConstantNode || validated[i] is ExprContextPropertyNode) {
indexNumericSize = i;
break;
}
}
if (indexNumericSize == -1) {
throw new ViewParameterException("Failed to find constant value for the numeric size parameter");
}
if (indexNumericSize == 0) {
throw new ViewParameterException(
"Failed to find unique value expressions that are expected to occur before the numeric size parameter");
}
if (indexNumericSize == validated.Length - 1) {
throw new ViewParameterException(
"Failed to find sort key expressions after the numeric size parameter");
}
// validate non-constant for unique-keys and sort-keys
for (var i = 0; i < indexNumericSize; i++) {
ViewForgeSupport.AssertReturnsNonConstant(NAME, validated[i], i);
}
for (var i = indexNumericSize + 1; i < validated.Length; i++) {
ViewForgeSupport.AssertReturnsNonConstant(NAME, validated[i], i);
}
// get sort size
ViewForgeSupport.ValidateNoProperties(ViewName, validated[indexNumericSize], indexNumericSize);
sizeForge = ViewForgeSupport.ValidateSizeParam(ViewName, validated[indexNumericSize], indexNumericSize);
// compile unique expressions
criteriaExpressions = new ExprNode[indexNumericSize];
Array.Copy(validated, 0, criteriaExpressions, 0, indexNumericSize);
// compile sort expressions
sortCriteriaExpressions = new ExprNode[validated.Length - indexNumericSize - 1];
isDescendingValues = new bool[sortCriteriaExpressions.Length];
var count = 0;
for (var i = indexNumericSize + 1; i < validated.Length; i++) {
if (validated[i] is ExprOrderedExpr) {
isDescendingValues[count] = ((ExprOrderedExpr) validated[i]).IsDescending;
sortCriteriaExpressions[count] = validated[i].ChildNodes[0];
}
else {
sortCriteriaExpressions[count] = validated[i];
}
count++;
}
sortSerdes = viewForgeEnv.SerdeResolver.SerdeForDataWindowSortCriteria(
ExprNodeUtilityQuery.GetExprResultTypes(sortCriteriaExpressions),
viewForgeEnv.StatementRawInfo);
}