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 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 void InstanceCodegen(
CodegenInstanceAux instance,
CodegenClassScope classScope,
CodegenCtor factoryCtor,
IList<CodegenTypedParam> factoryMembers)
{
instance.Properties.AddProperty(
typeof(SelectExprProcessor),
"SelectExprProcessor",
GetType(),
classScope,
propertyNode => propertyNode.GetterBlock.BlockReturn(MEMBER_SELECTEXPRPROCESSOR));
instance.Properties.AddProperty(
typeof(AggregationService),
"AggregationService",
GetType(),
classScope,
propertyNode => propertyNode.GetterBlock.BlockReturn(MEMBER_AGGREGATIONSVC));
instance.Methods.AddMethod(
typeof(ExprEvaluatorContext),
"GetAgentInstanceContext",
EmptyList<CodegenNamedParam>.Instance,
GetType(),
classScope,
node => node.Block.ReturnMethodOrBlock(MEMBER_AGENTINSTANCECONTEXT));
instance.Properties.AddProperty(
typeof(bool),
"HasHavingClause",
GetType(),
classScope,
propertyNode => propertyNode.GetterBlock.BlockReturn(Constant(OptionalHavingNode != null)));
instance.Properties.AddProperty(
typeof(bool),
"IsSelectRStream",
typeof(ResultSetProcessorRowForAll),
classScope,
propertyNode => propertyNode.GetterBlock.BlockReturn(Constant(IsSelectRStream)));
ResultSetProcessorUtil.EvaluateHavingClauseCodegen(OptionalHavingNode, classScope, instance);
GenerateGroupKeySingle = ResultSetProcessorGroupedUtil.GenerateGroupKeySingleCodegen(GroupKeyNodeExpressions, multiKeyClassRef, classScope, instance);
GenerateGroupKeyArrayView = ResultSetProcessorGroupedUtil.GenerateGroupKeyArrayViewCodegen(GenerateGroupKeySingle, classScope, instance);
GenerateGroupKeyArrayJoin = ResultSetProcessorGroupedUtil.GenerateGroupKeyArrayJoinCodegen(GenerateGroupKeySingle, classScope, instance);
ResultSetProcessorRowPerGroupImpl.GenerateOutputBatchedNoSortWMapCodegen(this, classScope, instance);
ResultSetProcessorRowPerGroupImpl.GenerateOutputBatchedArrFromEnumeratorCodegen(this, classScope, instance);
ResultSetProcessorRowPerGroupImpl.RemovedAggregationGroupKeyCodegen(classScope, instance);
if (unboundedProcessor) {
var factory = classScope.AddOrGetDefaultFieldSharable(ResultSetProcessorHelperFactoryField.INSTANCE);
instance.AddMember(NAME_GROUPREPS, typeof(ResultSetProcessorRowPerGroupUnboundHelper));
CodegenExpression groupKeySerde = MultiKeyClassRef.GetExprMKSerde(classScope.NamespaceScope.InitMethod, classScope);
var eventType = classScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(typesPerStream[0], EPStatementInitServicesConstants.REF));
instance.ServiceCtor.Block
.AssignRef(
NAME_GROUPREPS,
ExprDotMethod(
factory,
"MakeRSRowPerGroupUnboundGroupRep",
Constant(groupKeyTypes),
groupKeySerde,
eventType,
MEMBER_AGENTINSTANCECONTEXT))
.ExprDotMethod(MEMBER_AGGREGATIONSVC, "SetRemovedCallback", Member(NAME_GROUPREPS));
}
else {
instance.ServiceCtor.Block
.ExprDotMethod(MEMBER_AGGREGATIONSVC, "SetRemovedCallback", Ref("this"));
}
}
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 Codegen(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(AggregationGroupByRollupLevel), GetType(), classScope);
var serde = ConstantNull();
if (RollupKeys != null) {
if (_allGroupKeyTypes.Length == RollupKeys.Length) {
serde = _allKeysMultikey.GetExprMKSerde(method, classScope);
}
else {
serde = _subKeyMultikey.GetExprMKSerde(method, classScope);
}
}
// CodegenExpressionNewAnonymousClass clazz = NewAnonymousClass(
// method.Block,
// typeof(AggregationGroupByRollupLevel),
// Arrays.AsList(Constant(_levelNumber), Constant(_levelOffset), Constant(RollupKeys), serde));
// var computeSubkey = CodegenMethod
// .MakeParentNode(typeof(object), GetType(), classScope)
// .AddParam(typeof(object), "groupKey");
// clazz.AddMethod("computeSubkey", computeSubkey);
var computeSubkey = new CodegenExpressionLambda(method.Block)
.WithParam(typeof(object), "groupKey")
.WithBody(
block => {
if (IsAggregationTop) {
block.BlockReturn(ConstantNull());
}
else if (_allKeysMultikey == null || _allGroupKeyTypes.Length == RollupKeys.Length) {
block.BlockReturn(Ref("groupKey"));
}
else {
if (_allKeysMultikey.ClassNameMK.Type != null) {
block.DeclareVar(
_allKeysMultikey.ClassNameMK.Type,
"mk",
Cast(_allKeysMultikey.ClassNameMK.Type, Ref("groupKey")));
}
else {
block.DeclareVar(
_allKeysMultikey.ClassNameMK.Name,
"mk",
Cast(_allKeysMultikey.ClassNameMK.Name, Ref("groupKey")));
}
if (RollupKeys.Length == 1 && (_subKeyMultikey == null || _subKeyMultikey.ClassNameMK == null)) {
block.BlockReturn(ExprDotMethod(Ref("mk"), "GetKey", Constant(RollupKeys[0])));
}
else {
var expressions = new CodegenExpression[RollupKeys.Length];
for (var i = 0; i < RollupKeys.Length; i++) {
var index = RollupKeys[i];
var keyExpr = ExprDotMethod(Ref("mk"), "GetKey", Constant(index));
expressions[i] = Cast(_allGroupKeyTypes[index], keyExpr);
}
var instance = _subKeyMultikey.ClassNameMK.Type != null
? NewInstance(_subKeyMultikey.ClassNameMK.Type, expressions)
: NewInstanceInner(_subKeyMultikey.ClassNameMK.Name, expressions);
block.BlockReturn(instance);
}
}
});
var clazz = NewInstance<ProxyAggregationGroupByRollupLevel>(
Constant(_levelNumber),
Constant(_levelOffset),
Constant(RollupKeys),
serde,
computeSubkey);
method.Block.MethodReturn(clazz);
return LocalMethod(method);
}