public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(HistoricalIndexLookupStrategyComposite), GetType(), classScope);
method.Block.DeclareVar<QueryGraphValueEntryRange[]>(
"rangeGetters",
NewArrayByLength(typeof(QueryGraphValueEntryRange), Constant(ranges.Length)));
for (var i = 0; i < ranges.Length; i++) {
method.Block.AssignArrayElement(
Ref("rangeGetters"),
Constant(i),
ranges[i].Make(null, method, symbols, classScope));
}
var hashGetter = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(evaluators, null, multiKeyClasses, method, classScope);
method.Block
.DeclareVar<HistoricalIndexLookupStrategyComposite>(
"strat",
NewInstance(typeof(HistoricalIndexLookupStrategyComposite)))
.SetProperty(Ref("strat"), "LookupStream", Constant(lookupStream))
.SetProperty(Ref("strat"), "HashGetter", hashGetter)
.SetProperty(Ref("strat"), "RangeProps", Ref("rangeGetters"))
.ExprDotMethod(Ref("strat"), "Init")
.MethodReturn(Ref("strat"));
return LocalMethod(method);
}
protected override IList<CodegenExpression> AdditionalParams(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
IList<CodegenExpression> @params = new List<CodegenExpression>();
@params.Add(Constant(indexedProps));
@params.Add(Constant(hashCoercionDesc.CoercionTypes));
@params.Add(Constant(unique));
var propertyTypes = EventTypeUtility.GetPropertyTypes(eventType, indexedProps);
var getters = EventTypeUtility.GetGetters(eventType, indexedProps);
var getter = MultiKeyCodegen.CodegenGetterMayMultiKey(
eventType,
getters,
propertyTypes,
hashCoercionDesc.CoercionTypes,
multiKeyClassRef,
method,
classScope);
@params.Add(getter);
@params.Add(ConstantNull()); // no fire-and-forget transform for subqueries
@params.Add(multiKeyClassRef.GetExprMKSerde(method, classScope));
return @params;
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(PollResultIndexingStrategyHash), GetType(), classScope);
var propertyGetters = EventTypeUtility.GetGetters(_eventType, _propertyNames);
var propertyTypes = EventTypeUtility.GetPropertyTypes(_eventType, _propertyNames);
var valueGetter = MultiKeyCodegen.CodegenGetterMayMultiKey(
_eventType,
propertyGetters,
propertyTypes,
_coercionTypes,
_multiKeyClasses,
method,
classScope);
method.Block
.DeclareVar<PollResultIndexingStrategyHash>(
"strat",
NewInstance(typeof(PollResultIndexingStrategyHash)))
.SetProperty(Ref("strat"), "StreamNum", Constant(_streamNum))
.SetProperty(Ref("strat"), "PropertyNames", Constant(_propertyNames))
.SetProperty(Ref("strat"), "ValueGetter", valueGetter)
.ExprDotMethod(Ref("strat"), "Init")
.MethodReturn(Ref("strat"));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(QueryPlanIndexItem), GetType(), classScope);
var propertyGetters = EventTypeUtility.GetGetters(eventType, HashProps);
var propertyTypes = EventTypeUtility.GetPropertyTypes(eventType, HashProps);
var valueGetter = MultiKeyCodegen.CodegenGetterMayMultiKey(
eventType, propertyGetters, propertyTypes, HashTypes, HashMultiKeyClasses, method, classScope);
CodegenExpression rangeGetters;
if (RangeProps.Length == 0) {
rangeGetters = NewArrayByLength(typeof(EventPropertyValueGetter), Constant(0));
}
else {
var makeMethod = parent.MakeChild(typeof(EventPropertyValueGetter[]), GetType(), classScope);
makeMethod.Block.DeclareVar<EventPropertyValueGetter[]>(
"getters",
NewArrayByLength(typeof(EventPropertyValueGetter), Constant(RangeProps.Length)));
for (var i = 0; i < RangeProps.Length; i++) {
var getter = ((EventTypeSPI) eventType).GetGetterSPI(RangeProps[i]);
var getterType = eventType.GetPropertyType(RangeProps[i]);
var coercionType = RangeTypes == null ? null : RangeTypes[i];
var eval = EventTypeUtility.CodegenGetterWCoerce(
getter,
getterType,
coercionType,
method,
GetType(),
classScope);
makeMethod.Block.AssignArrayElement(Ref("getters"), Constant(i), eval);
}
makeMethod.Block.MethodReturn(Ref("getters"));
rangeGetters = LocalMethod(makeMethod);
}
CodegenExpression multiKeyTransform = MultiKeyCodegen.CodegenMultiKeyFromArrayTransform(
HashMultiKeyClasses, method, classScope);
method.Block.MethodReturn(
NewInstance<QueryPlanIndexItem>(
Constant(HashProps),
Constant(HashTypes),
valueGetter,
multiKeyTransform,
HashMultiKeyClasses != null ? HashMultiKeyClasses.GetExprMKSerde(method, classScope) : ConstantNull(),
Constant(RangeProps),
Constant(RangeTypes),
rangeGetters,
DataInputOutputSerdeForgeExtensions.CodegenArray(RangeSerdes, method, classScope, null),
Constant(IsUnique),
AdvancedIndexProvisionDesc == null
? ConstantNull()
: AdvancedIndexProvisionDesc.CodegenMake(method, classScope)));
return LocalMethod(method);
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
// add aggregation row+factory+serde as inner classes
var aggregationClassNames = new AggregationClassNames();
var inners = AggregationServiceFactoryCompiler.MakeTable(
AggregationCodegenRowLevelDesc.FromTopOnly(_plan.AggDesc),
GetType(),
classScope,
aggregationClassNames,
_className);
classScope.AddInnerClasses(inners);
var method = parent.MakeChild(typeof(StatementAgentInstanceFactoryCreateTable), GetType(), classScope);
CodegenExpression primaryKeyGetter = MultiKeyCodegen.CodegenGetterMayMultiKey(
_plan.InternalEventType,
_plan.PrimaryKeyGetters,
_plan.PrimaryKeyTypes,
null,
_plan.PrimaryKeyMultikeyClasses,
method,
classScope);
CodegenExpression fafTransform = MultiKeyCodegen.CodegenMultiKeyFromArrayTransform(
_plan.PrimaryKeyMultikeyClasses,
method,
classScope);
CodegenExpression intoTableTransform = MultiKeyCodegen.CodegenMultiKeyFromMultiKeyTransform(
_plan.PrimaryKeyMultikeyClasses,
method,
classScope);
var propertyForgeEval = DataInputOutputSerdeForgeExtensions.CodegenArray(
_plan.InternalEventTypePropertySerdes,
method,
classScope,
ExprDotName(symbols.GetAddInitSvc(method), EPStatementInitServicesConstants.EVENTTYPERESOLVER));
method.Block
.DeclareVar<StatementAgentInstanceFactoryCreateTable>("saiff", NewInstance(typeof(StatementAgentInstanceFactoryCreateTable)))
.SetProperty(Ref("saiff"), "TableName", Constant(_tableName))
.SetProperty(Ref("saiff"), "PublicEventType", EventTypeUtility.ResolveTypeCodegen(_plan.PublicEventType, symbols.GetAddInitSvc(method)))
.SetProperty(Ref("saiff"), "EventToPublic", MakeEventToPublic(method, symbols, classScope))
.SetProperty(Ref("saiff"), "AggregationRowFactory", NewInstanceInner(aggregationClassNames.RowFactoryTop, Ref("this")))
.SetProperty(Ref("saiff"), "AggregationSerde", NewInstanceInner(aggregationClassNames.RowSerdeTop, Ref("this")))
.SetProperty(Ref("saiff"), "PrimaryKeyGetter", primaryKeyGetter)
.SetProperty(Ref("saiff"), "PrimaryKeySerde", _plan.PrimaryKeyMultikeyClasses.GetExprMKSerde(method, classScope))
.SetProperty(Ref("saiff"), "PropertyForges", propertyForgeEval)
.SetProperty(Ref("saiff"), "PrimaryKeyObjectArrayTransform", fafTransform)
.SetProperty(Ref("saiff"), "PrimaryKeyIntoTableTransform", intoTableTransform)
.ExprDotMethod(symbols.GetAddInitSvc(method), "AddReadyCallback", Ref("saiff"))
.MethodReturn(Ref("saiff"));
return method;
}
public static CodegenMethod GenerateGroupKeySingleCodegen(
ExprNode[] groupKeyExpressions,
MultiKeyClassRef optionalMultiKeyClasses,
CodegenClassScope classScope,
CodegenInstanceAux instance)
{
Consumer<CodegenMethod> code = methodNode => {
string[] expressions = null;
if (classScope.IsInstrumented) {
expressions = ExprNodeUtilityPrint.ToExpressionStringsMinPrecedence(groupKeyExpressions);
}
methodNode.Block.Apply(
Instblock(
classScope,
"qResultSetProcessComputeGroupKeys",
ExprForgeCodegenNames.REF_ISNEWDATA,
Constant(expressions),
REF_EPS));
if (optionalMultiKeyClasses != null && optionalMultiKeyClasses.ClassNameMK != null) {
var method = MultiKeyCodegen.CodegenMethod(groupKeyExpressions, optionalMultiKeyClasses, methodNode, classScope);
methodNode
.Block
.DeclareVar<object>("key", LocalMethod(method, REF_EPS, ExprForgeCodegenNames.REF_ISNEWDATA, MEMBER_AGENTINSTANCECONTEXT))
.Apply(Instblock(classScope, "aResultSetProcessComputeGroupKeys", ExprForgeCodegenNames.REF_ISNEWDATA, Ref("key")))
.MethodReturn(Ref("key"));
return;
}
if (groupKeyExpressions.Length > 1) {
throw new IllegalStateException("Multiple group-by expression and no multikey");
}
var expression = CodegenLegoMethodExpression.CodegenExpression(groupKeyExpressions[0].Forge, methodNode, classScope);
methodNode
.Block
.DeclareVar<object>("key", LocalMethod(expression, REF_EPS, ExprForgeCodegenNames.REF_ISNEWDATA, MEMBER_AGENTINSTANCECONTEXT))
.Apply(Instblock(classScope, "aResultSetProcessComputeGroupKeys", ExprForgeCodegenNames.REF_ISNEWDATA, Ref("key")))
.MethodReturn(Ref("key"));
};
return instance.Methods.AddMethod(
typeof(object),
"GenerateGroupKeySingle",
CodegenNamedParam.From(
typeof(EventBean[]),
NAME_EPS,
typeof(bool),
ResultSetProcessorCodegenNames.NAME_ISNEWDATA),
typeof(ResultSetProcessorUtil),
classScope,
code);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var methodNode = parent.MakeChild(typeof(SubordTableLookupStrategyFactory), GetType(), classScope);
if (_isStrictKeys) {
int[] keyStreamNums = IntArrayUtil.Copy(_keyStreamNumbers);
var keyStreamTypes = _outerStreamTypesZeroIndexed;
if (isNWOnTrigger) {
keyStreamTypes = EventTypeUtility.ShiftRight(_outerStreamTypesZeroIndexed);
for (var i = 0; i < keyStreamNums.Length; i++) {
keyStreamNums[i] = keyStreamNums[i] + 1;
}
}
var forges = ExprNodeUtilityQuery.ForgesForProperties(
keyStreamTypes, _hashStrictKeys, keyStreamNums);
var eval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(
forges,
_hashKeyCoercionTypes.CoercionTypes,
_hashMultikeyClasses,
methodNode,
classScope);
methodNode.Block.MethodReturn(
NewInstance<SubordHashedTableLookupStrategyPropFactory>(
Constant(_hashStrictKeys),
Constant(keyStreamNums),
eval));
return LocalMethod(methodNode);
}
else {
var forges = new ExprForge[_hashKeys.Count];
for (var i = 0; i < _hashKeys.Count; i++) {
forges[i] = _hashKeys[i].HashKey.KeyExpr.Forge;
}
var expressions = ExprNodeUtilityPrint.ToExpressionStringsMinPrecedence(forges);
var eval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(
forges,
_hashKeyCoercionTypes.CoercionTypes,
_hashMultikeyClasses,
methodNode,
classScope);
methodNode.Block.MethodReturn(
NewInstance<SubordHashedTableLookupStrategyExprFactory>(
Constant(expressions),
eval,
Constant(isNWOnTrigger),
Constant(_numStreamsOuter)));
return LocalMethod(methodNode);
}
}
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 Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(PollResultIndexingStrategyComposite), GetType(), classScope);
var hashGetter = ConstantNull();
if (optHashPropertyNames != null) {
var propertyGetters = EventTypeUtility.GetGetters(eventType, optHashPropertyNames);
var propertyTypes = EventTypeUtility.GetPropertyTypes(eventType, optHashPropertyNames);
hashGetter = MultiKeyCodegen.CodegenGetterMayMultiKey(
eventType,
propertyGetters,
propertyTypes,
optHashCoercedTypes,
optHashMultiKeyClasses,
method,
classScope);
}
method.Block.DeclareVar<EventPropertyValueGetter[]>(
"rangeGetters",
NewArrayByLength(typeof(EventPropertyValueGetter), Constant(rangeProps.Length)));
for (var i = 0; i < rangeProps.Length; i++) {
var propertyType = eventType.GetPropertyType(rangeProps[i]);
var getterSPI = ((EventTypeSPI) eventType).GetGetterSPI(rangeProps[i]);
var getter = EventTypeUtility.CodegenGetterWCoerce(
getterSPI,
propertyType,
rangeTypes[i],
method,
GetType(),
classScope);
method.Block.AssignArrayElement(Ref("rangeGetters"), Constant(i), getter);
}
method.Block
.DeclareVar<PollResultIndexingStrategyComposite>(
"strat",
NewInstance(typeof(PollResultIndexingStrategyComposite)))
.SetProperty(Ref("strat"), "StreamNum", Constant(streamNum))
.SetProperty(Ref("strat"), "OptionalKeyedProps", Constant(optHashPropertyNames))
.SetProperty(Ref("strat"), "OptKeyCoercedTypes", Constant(optHashCoercedTypes))
.SetProperty(Ref("strat"), "HashGetter", hashGetter)
.SetProperty(Ref("strat"), "RangeProps", Constant(rangeProps))
.SetProperty(Ref("strat"), "OptRangeCoercedTypes", Constant(rangeTypes))
.SetProperty(Ref("strat"), "RangeGetters", Ref("rangeGetters"))
.ExprDotMethod(Ref("strat"), "Init")
.MethodReturn(Ref("strat"));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(StatementInformationalsRuntime), GetType(), classScope);
var info = Ref("info");
var annotationsExpr = _annotations == null
? ConstantNull()
: LocalMethod(MakeAnnotations(typeof(Attribute[]), _annotations, method, classScope));
method.Block
.DeclareVar<StatementInformationalsRuntime>(
info.Ref,
NewInstance(typeof(StatementInformationalsRuntime)))
.SetProperty(info, "StatementNameCompileTime", Constant(_statementNameCompileTime))
.SetProperty(info, "IsAlwaysSynthesizeOutputEvents", Constant(_alwaysSynthesizeOutputEvents))
.SetProperty(info, "OptionalContextName", Constant(_optionalContextName))
.SetProperty(info, "OptionalContextModuleName", Constant(_optionalContextModuleName))
.SetProperty(info, "OptionalContextVisibility", Constant(_optionalContextVisibility))
.SetProperty(info, "IsCanSelfJoin", Constant(_canSelfJoin))
.SetProperty(info, "HasSubquery", Constant(_hasSubquery))
.SetProperty(info, "IsNeedDedup", Constant(_needDedup))
.SetProperty(info, "IsStateless", Constant(_stateless))
.SetProperty(info, "Annotations", annotationsExpr)
.SetProperty(info, "UserObjectCompileTime", SerializerUtil.ExpressionForUserObject(_userObjectCompileTime))
.SetProperty(info, "NumFilterCallbacks", Constant(_numFilterCallbacks))
.SetProperty(info, "NumScheduleCallbacks", Constant(_numScheduleCallbacks))
.SetProperty(info, "NumNamedWindowCallbacks", Constant(_numNamedWindowCallbacks))
.SetProperty(info, "StatementType", Constant(_statementType))
.SetProperty(info, "Priority", Constant(_priority))
.SetProperty(info, "IsPreemptive", Constant(_preemptive))
.SetProperty(info, "HasVariables", Constant(_hasVariables))
.SetProperty(info, "IsWritesToTables", Constant(_writesToTables))
.SetProperty(info, "HasTableAccess", Constant(_hasTableAccess))
.SetProperty(info, "SelectClauseTypes", Constant(_selectClauseTypes))
.SetProperty(info, "SelectClauseColumnNames", Constant(_selectClauseColumnNames))
.SetProperty(info, "IsForClauseDelivery", Constant(_forClauseDelivery))
.SetProperty(info, "GroupDeliveryEval", MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(_groupDelivery, null, _groupDeliveryMultiKey, method, classScope))
.SetProperty(info, "Properties", MakeProperties(_properties, method, classScope))
.SetProperty(info, "HasMatchRecognize", Constant(_hasMatchRecognize))
.SetProperty(info, "AuditProvider", MakeAuditProvider(method, classScope))
.SetProperty(info, "IsInstrumented", Constant(_instrumented))
.SetProperty(info, "InstrumentationProvider", MakeInstrumentationProvider(method, classScope))
.SetProperty(info, "SubstitutionParamTypes", MakeSubstitutionParamTypes())
.SetProperty(info, "SubstitutionParamNames", MakeSubstitutionParamNames(method, classScope))
.SetProperty(info, "InsertIntoLatchName", Constant(_insertIntoLatchName))
.SetProperty(info, "IsAllowSubscriber", Constant(_allowSubscriber))
.SetProperty(info, "OnScripts", MakeOnScripts(_onScripts, method, classScope))
.MethodReturn(info);
return LocalMethod(method);
}
public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ContextControllerDetailKeyed), GetType(), classScope);
method.Block.DeclareVar<ContextControllerDetailKeyedItem[]>(
"items",
NewArrayByLength(typeof(ContextControllerDetailKeyedItem), Constant(Items.Count)));
for (var i = 0; i < Items.Count; i++) {
method.Block.AssignArrayElement(
"items",
Constant(i),
Items[i].MakeCodegen(method, symbols, classScope));
}
method.Block
.DeclareVar<ContextControllerDetailKeyed>("detail", NewInstance(typeof(ContextControllerDetailKeyed)))
.SetProperty(Ref("detail"), "Items", Ref("items"))
.SetProperty(Ref("detail"), "MultiKeyFromObjectArray", MultiKeyCodegen.CodegenMultiKeyFromArrayTransform(MultiKeyClassRef, method, classScope));
if (OptionalInit != null && !OptionalInit.IsEmpty()) {
method.Block.DeclareVar<ContextConditionDescriptorFilter[]>(
"init",
NewArrayByLength(typeof(ContextConditionDescriptorFilter), Constant(OptionalInit.Count)));
for (var i = 0; i < OptionalInit.Count; i++) {
method.Block.AssignArrayElement(
"init",
Constant(i),
Cast(
typeof(ContextConditionDescriptorFilter),
OptionalInit[i].Make(method, symbols, classScope)));
}
method.Block.SetProperty(Ref("detail"), "OptionalInit", Ref("init"));
}
if (OptionalTermination != null) {
method.Block.SetProperty(
Ref("detail"),
"OptionalTermination",
OptionalTermination.Make(method, symbols, classScope));
}
method.Block.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method)).Add("AddReadyCallback", Ref("detail")))
.MethodReturn(Ref("detail"));
return LocalMethod(method);
}
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));
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(PropertyCompositeEventTableFactoryFactory), GetType(), classScope);
var hashGetter = ConstantNull();
if (_optKeyProps != null && _optKeyProps.Length > 0) {
var propertyTypes = EventTypeUtility.GetPropertyTypes(_eventType, _optKeyProps);
var getters = EventTypeUtility.GetGetters(_eventType, _optKeyProps);
hashGetter = MultiKeyCodegen.CodegenGetterMayMultiKey(
_eventType, getters, propertyTypes, _optKeyTypes, _hashMultikeyClasses, method, classScope);
}
method.Block.DeclareVar<EventPropertyValueGetter[]>(
"rangeGetters",
NewArrayByLength(typeof(EventPropertyValueGetter), Constant(_rangeProps.Length)));
for (var i = 0; i < _rangeProps.Length; i++) {
var propertyType = _eventType.GetPropertyType(_rangeProps[i]);
var getterSPI = ((EventTypeSPI) _eventType).GetGetterSPI(_rangeProps[i]);
var getter = EventTypeUtility.CodegenGetterWCoerce(
getterSPI,
propertyType,
_rangeTypes[i],
method,
GetType(),
classScope);
method.Block.AssignArrayElement(Ref("rangeGetters"), Constant(i), getter);
}
IList<CodegenExpression> @params = new List<CodegenExpression>();
@params.Add(Constant(_indexedStreamNum));
@params.Add(Constant(_subqueryNum));
@params.Add(Constant(_isFireAndForget));
@params.Add(Constant(_optKeyProps));
@params.Add(Constant(_optKeyTypes));
@params.Add(hashGetter);
@params.Add(_hashMultikeyClasses.GetExprMKSerde(method, classScope));
@params.Add(Constant(_rangeProps));
@params.Add(Constant(_rangeTypes));
@params.Add(Ref("rangeGetters"));
@params.Add(DataInputOutputSerdeForgeExtensions.CodegenArray(_rangeSerdes, method, classScope, null));
method.Block.MethodReturn(
NewInstance<PropertyCompositeEventTableFactoryFactory>(@params.ToArray()));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(HistoricalIndexLookupStrategyHash), GetType(), classScope);
var evaluator = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(
_evaluators, _coercionTypes, _multiKeyClassRef, method, classScope);
method.Block
.DeclareVar<HistoricalIndexLookupStrategyHash>(
"strat",
NewInstance(typeof(HistoricalIndexLookupStrategyHash)))
.SetProperty(Ref("strat"), "LookupStream", Constant(_lookupStream))
.SetProperty(Ref("strat"), "Evaluator", evaluator)
.MethodReturn(Ref("strat"));
return LocalMethod(method);
}
public void ProvideCodegen(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block.MethodReturn(
NewInstance<OutputProcessViewDirectDistinctOrAfterFactory>(
_outputStrategyPostProcessForge == null
? ConstantNull()
: _outputStrategyPostProcessForge.Make(method, symbols, classScope),
Constant(_isDistinct),
MultiKeyCodegen.CodegenGetterEventDistinct(
_isDistinct, ResultEventType, DistinctMultiKey, method, classScope),
AfterTimePeriod == null
? ConstantNull()
: AfterTimePeriod.TimePeriodComputeForge.MakeEvaluator(method, classScope),
Constant(AfterConditionNumberOfEvents),
EventTypeUtility.ResolveTypeCodegen(ResultEventType, symbols.GetAddInitSvc(method))));
}
public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(SubSelectStrategyFactoryIndexShare), GetType(), classScope);
CodegenExpression groupKeyEval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(_groupKeys, null, _groupByMultiKey, method, classScope);
var tableExpr = _table == null
? ConstantNull()
: TableDeployTimeResolver.MakeResolveTable(_table, symbols.GetAddInitSvc(method));
var namedWindowExpr = _namedWindow == null
? ConstantNull()
: NamedWindowDeployTimeResolver.MakeResolveNamedWindow(_namedWindow, symbols.GetAddInitSvc(method));
var aggregationServiceFactoryExpr = SubSelectStrategyFactoryLocalViewPreloadedForge.MakeAggregationService(
_subqueryNumber,
_aggregationServiceForgeDesc,
classScope,
method,
symbols);
var filterExprEvalExpr = _filterExprEval == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluatorNoCoerce(_filterExprEval, method, GetType(), classScope);
var queryPlanExpr = _queryPlan == null
? ConstantNull()
: _queryPlan.Make(method, symbols, classScope);
method.Block
.DeclareVar <SubSelectStrategyFactoryIndexShare>("s", NewInstance(typeof(SubSelectStrategyFactoryIndexShare)))
.SetProperty(Ref("s"), "Table", tableExpr)
.SetProperty(Ref("s"), "NamedWindow", namedWindowExpr)
.SetProperty(Ref("s"), "AggregationServiceFactory", aggregationServiceFactoryExpr)
.SetProperty(Ref("s"), "FilterExprEval", filterExprEvalExpr)
.SetProperty(Ref("s"), "GroupKeyEval", groupKeyEval)
.SetProperty(Ref("s"), "QueryPlan", queryPlanExpr)
.MethodReturn(Ref("s"));
return(LocalMethod(method));
}
public override ICollection<CodegenExpression> AdditionalParams(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var hashGetter = ConstantNull();
if (!_hashKeys.IsEmpty()) {
var indexForge = _indexSpecs.Items.Get(IndexNum[0]);
var forges = QueryGraphValueEntryHashKeyedForge.GetForges(_hashKeys.ToArray());
if (indexForge != null) {
hashGetter = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(
forges,
_hashCoercionTypes,
indexForge.HashMultiKeyClasses,
method,
classScope);
} else {
hashGetter = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(
forges,
_hashCoercionTypes,
_optionalEPLTableLookupMultiKey,
method,
classScope);
}
}
var rangeGetters = method.MakeChild(typeof(QueryGraphValueEntryRange[]), GetType(), classScope);
rangeGetters.Block.DeclareVar<QueryGraphValueEntryRange[]>(
"rangeGetters",
NewArrayByLength(typeof(QueryGraphValueEntryRange), Constant(_rangeKeyPairs.Count)));
for (var i = 0; i < _rangeKeyPairs.Count; i++) {
var optCoercionType = _optRangeCoercionTypes == null ? null : _optRangeCoercionTypes[i];
rangeGetters.Block.AssignArrayElement(
Ref("rangeGetters"),
Constant(i),
_rangeKeyPairs[i].Make(optCoercionType, rangeGetters, symbols, classScope));
}
rangeGetters.Block.MethodReturn(Ref("rangeGetters"));
return Arrays.AsList(hashGetter, LocalMethod(rangeGetters));
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(SubordCompositeTableLookupStrategyFactory), GetType(), classScope);
IList<string> expressions = new List<string>();
var hashEval = ConstantNull();
if (_hashKeys != null && !_hashKeys.IsEmpty()) {
var forges = new ExprForge[_hashKeys.Count];
for (var i = 0; i < _hashKeys.Count; i++) {
forges[i] = _hashKeys[i].HashKey.KeyExpr.Forge;
}
expressions.AddAll(ExprNodeUtilityPrint.ToExpressionStringsMinPrecedence(forges));
hashEval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(forges, _hashTypes, _hashMultikeyClasses, method, classScope);
}
method.Block.DeclareVar<QueryGraphValueEntryRange[]>(
"rangeEvals",
NewArrayByLength(typeof(QueryGraphValueEntryRange), Constant(_rangeProps.Count)));
for (var i = 0; i < _rangeProps.Count; i++) {
CodegenExpression rangeEval = _rangeProps[i]
.RangeInfo.Make(
_coercionRangeTypes[i],
parent,
symbols,
classScope);
method.Block.AssignArrayElement(Ref("rangeEvals"), Constant(i), rangeEval);
}
method.Block.MethodReturn(
NewInstance<SubordCompositeTableLookupStrategyFactory>(
Constant(_isNWOnTrigger),
Constant(_numStreams),
Constant(expressions.ToArray()),
hashEval,
Ref("rangeEvals")));
return LocalMethod(method);
}
public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(SubSelectStrategyFactoryLocalViewPreloaded), GetType(), classScope);
CodegenExpression groupKeyEval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(_groupKeys, null, _groupByMultiKeyClasses, method, classScope);
method.Block
.DeclareVar <SubSelectStrategyFactoryLocalViewPreloaded>("factory", NewInstance(typeof(SubSelectStrategyFactoryLocalViewPreloaded)))
.SetProperty(Ref("factory"), "SubqueryNumber", Constant(_subqueryNumber))
.SetProperty(Ref("factory"), "ViewFactories", ViewFactoryForgeUtil.CodegenForgesWInit(_viewForges, 0, _subqueryNumber, method, symbols, classScope))
.SetProperty(Ref("factory"), "ViewResourceDelegate", _viewResourceDelegateDesc.ToExpression())
.SetProperty(Ref("factory"), "EventTableFactoryFactory", _lookupStrategy.First.Make(method, symbols, classScope))
.SetProperty(Ref("factory"), "LookupStrategyFactory", _lookupStrategy.Second.Make(method, symbols, classScope))
.SetProperty(Ref("factory"), "AggregationServiceFactory", MakeAggregationService(_subqueryNumber, _aggregationServiceForgeDesc, classScope, method, symbols))
.SetProperty(Ref("factory"), "CorrelatedSubquery", Constant(_correlatedSubquery))
.SetProperty(Ref("factory"), "GroupKeyEval", groupKeyEval)
.SetProperty(Ref("factory"), "FilterExprEval", _filterExprNode == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluatorNoCoerce(_filterExprNode.Forge, method, GetType(), classScope));
if (_namedWindow != null)
{
method.Block.SetProperty(
Ref("factory"), "NamedWindow", NamedWindowDeployTimeResolver.MakeResolveNamedWindow(_namedWindow, symbols.GetAddInitSvc(method)));
if (_namedWindowFilterExpr != null)
{
method.Block
.SetProperty(Ref("factory"), "NamedWindowFilterQueryGraph",
_namedWindowFilterQueryGraph.Make(method, symbols, classScope))
.SetProperty(Ref("factory"), "NamedWindowFilterExpr",
ExprNodeUtilityCodegen.CodegenEvaluator(_namedWindowFilterExpr.Forge, method, GetType(), classScope));
}
}
method.Block.MethodReturn(Ref("factory"));
return(LocalMethod(method));
}
protected override void InlineInitializeOnTriggerSpecific(
CodegenExpressionRef saiff,
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block
.SetProperty(
saiff,
"ResultSetProcessorFactoryProvider",
NewInstanceInner(
resultSetProcessorProviderClassName,
symbols.GetAddInitSvc(method),
Ref("statementFields")))
.SetProperty(saiff, "IsInsertInto", Constant(insertInto))
.SetProperty(saiff, "IsAddToFront", Constant(addToFront))
.SetProperty(saiff, "IsSelectAndDelete", Constant(selectAndDelete))
.SetProperty(saiff, "IsDistinct", Constant(distinct))
.SetProperty(
saiff,
"DistinctKeyGetter",
MultiKeyCodegen.CodegenGetterEventDistinct(
distinct,
ResultEventType,
distinctMultiKey,
method,
classScope))
.SetProperty(
saiff,
"OptionalInsertIntoTable",
optionalInsertIntoTable == null
? ConstantNull()
: TableDeployTimeResolver.MakeResolveTable(
optionalInsertIntoTable,
symbols.GetAddInitSvc(method)));
}
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);
}
public void MakeMethod(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var select = Ref("select");
method.Block
.DeclareVar<FAFQueryMethodSelect>(select.Ref, NewInstance(typeof(FAFQueryMethodSelect)))
.SetProperty(
select,
"Annotations",
LocalMethod(
AnnotationUtil.MakeAnnotations(typeof(Attribute[]), _desc.Annotations, method, classScope)))
.SetProperty(
select,
"Processors",
FireAndForgetProcessorForgeExtensions.MakeArray(_desc.Processors, method, symbols, classScope))
.DeclareVar(
_classNameResultSetProcessor,
"rsp",
NewInstanceInner(_classNameResultSetProcessor, symbols.GetAddInitSvc(method), Ref("statementFields")))
.SetProperty(
select,
"ResultSetProcessorFactoryProvider",
Ref("rsp"))
.SetProperty(
select,
"QueryGraph",
_desc.QueryGraph.Make(method, symbols, classScope))
.SetProperty(
select,
"WhereClause",
_desc.WhereClause == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
_desc.WhereClause.Forge,
method,
GetType(),
classScope))
.SetProperty(
select,
"JoinSetComposerPrototype",
_desc.Joins == null ? ConstantNull() : _desc.Joins.Make(method, symbols, classScope))
.SetProperty(
select,
"ConsumerFilters",
ExprNodeUtilityCodegen.CodegenEvaluators(
_desc.ConsumerFilters,
method,
GetType(),
classScope))
.SetProperty(
select,
"ContextName",
Constant(_desc.ContextName))
.SetProperty(
select,
"TableAccesses",
ExprTableEvalStrategyUtil.CodegenInitMap(
_desc.TableAccessForges,
GetType(),
method,
symbols,
classScope))
.SetProperty(
select,
"HasTableAccess",
Constant(_desc.HasTableAccess))
.SetProperty(
select,
"IsDistinct",
Constant(_desc.IsDistinct))
.SetProperty(
select,
"DistinctKeyGetter",
MultiKeyCodegen.CodegenGetterEventDistinct(
_desc.IsDistinct,
_desc.ResultSetProcessor.ResultEventType,
_desc.DistinctMultiKey,
method,
classScope))
.SetProperty(
select,
"Subselects",
SubSelectFactoryForge.CodegenInitMap(
_desc.SubselectForges,
GetType(),
method,
symbols,
classScope))
.MethodReturn(select);
}
public void ProviderCodegen(
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
method.Block.DeclareVar<AggregationLocalGroupByLevel>("optionalTop", ConstantNull());
if (localGroupByPlan.OptionalLevelTopForge != null) {
method.Block.AssignRef(
"optionalTop",
localGroupByPlan.OptionalLevelTopForge.ToExpression(
classNames.RowFactoryTop,
classNames.RowSerdeTop,
ConstantNull(),
method,
classScope));
}
int numLevels = localGroupByPlan.AllLevelsForges.Length;
method.Block.DeclareVar<AggregationLocalGroupByLevel[]>(
"levels",
NewArrayByLength(typeof(AggregationLocalGroupByLevel), Constant(numLevels)));
for (var i = 0; i < numLevels; i++) {
AggregationLocalGroupByLevelForge forge = localGroupByPlan.AllLevelsForges[i];
CodegenExpression eval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(
forge.PartitionForges,
null,
forge.PartitionMKClasses,
method,
classScope);
method.Block.AssignArrayElement(
"levels",
Constant(i),
localGroupByPlan.AllLevelsForges[i]
.ToExpression(
classNames.GetRowFactoryPerLevel(i),
classNames.GetRowSerdePerLevel(i),
eval,
method,
classScope));
}
method.Block.DeclareVar<AggregationLocalGroupByColumn[]>(
"columns",
NewArrayByLength(
typeof(AggregationLocalGroupByColumn),
Constant(localGroupByPlan.ColumnsForges.Length)));
var rowLevelDesc = RowLevelDesc;
for (var i = 0; i < localGroupByPlan.ColumnsForges.Length; i++) {
AggregationLocalGroupByColumnForge col = localGroupByPlan.ColumnsForges[i];
int fieldNum;
if (hasGroupBy && col.IsDefaultGroupLevel) {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum];
fieldNum = GetRowFieldNum(col, levelDesc);
}
else if (col.LevelNum == -1) {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalTopRow;
fieldNum = GetRowFieldNum(col, levelDesc);
}
else {
AggregationCodegenRowDetailDesc levelDesc = rowLevelDesc.OptionalAdditionalRows[col.LevelNum];
fieldNum = GetRowFieldNum(col, levelDesc);
}
method.Block.AssignArrayElement(
"columns",
Constant(i),
localGroupByPlan.ColumnsForges[i].ToExpression(fieldNum));
}
method.Block
.DeclareVar<AggregationServiceFactory>(
"svcFactory",
NewInstanceInner(classNames.ServiceFactory, Ref("this")))
.MethodReturn(
ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(AGGREGATIONSERVICEFACTORYSERVICE)
.Add(
"GroupLocalGroupBy",
Ref("svcFactory"),
useFlags.ToExpression(),
Constant(hasGroupBy),
Ref("optionalTop"),
Ref("levels"),
Ref("columns")));
}
public void ProvideCodegen(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var spec = Ref("spec");
method.Block
.DeclareVar<OutputProcessViewConditionSpec>(
spec.Ref,
NewInstance(typeof(OutputProcessViewConditionSpec)))
.SetProperty(
spec,
"ConditionType",
EnumValue(typeof(ResultSetProcessorOutputConditionType), _conditionType.GetName()))
.SetProperty(
spec,
"OutputConditionFactory",
_outputConditionFactoryForge.Make(method, symbols, classScope))
.SetProperty(
spec,
"StreamCount",
Constant(_streamCount))
.SetProperty(
spec,
"IsTerminable",
Constant(_terminable))
.SetProperty(
spec,
"SelectClauseStreamSelector",
EnumValue(typeof(SelectClauseStreamSelectorEnum), _selectClauseStreamSelector.GetName()))
.SetProperty(
spec,
"PostProcessFactory",
_outputStrategyPostProcessForge == null
? ConstantNull()
: _outputStrategyPostProcessForge.Make(method, symbols, classScope))
.SetProperty(
spec,
"HasAfter",
Constant(_hasAfter))
.SetProperty(
spec,
"IsDistinct",
Constant(_isDistinct))
.SetProperty(
spec,
"DistinctKeyGetter",
MultiKeyCodegen.CodegenGetterEventDistinct(
_isDistinct, _resultEventType, _distinctMultiKey, method, classScope))
.SetProperty(
spec,
"ResultEventType",
EventTypeUtility.ResolveTypeCodegen(_resultEventType, symbols.GetAddInitSvc(method)))
.SetProperty(
spec,
"AfterTimePeriod",
_afterTimePeriodExpr == null
? ConstantNull()
: _afterTimePeriodExpr.TimePeriodComputeForge.MakeEvaluator(method, classScope))
.SetProperty(
spec,
"AfterConditionNumberOfEvents",
Constant(_afterNumberOfEvents))
.SetProperty(
spec,
"IsUnaggregatedUngrouped",
Constant(_unaggregatedUngrouped))
.SetProperty(
spec,
"EventTypes",
EventTypeUtility.ResolveTypeArrayCodegen(_eventTypes, EPStatementInitServicesConstants.REF))
.MethodReturn(NewInstance<OutputProcessViewConditionFactory>(spec));
}
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);
}
