public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ViewableActivatorTable), GetType(), classScope);
method.Block
.DeclareVar<ViewableActivatorTable>("va", NewInstance(typeof(ViewableActivatorTable)))
.SetProperty(
Ref("va"),
"Table",
TableDeployTimeResolver.MakeResolveTable(table, symbols.GetAddInitSvc(method)))
.SetProperty(
Ref("va"),
"FilterEval",
optionalFilterExpression == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
optionalFilterExpression.Forge,
method,
GetType(),
classScope))
.MethodReturn(Ref("va"));
return LocalMethod(method);
}
protected override void PopulateInline(
CodegenExpression impl,
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block
.SetProperty(Ref("impl"), "PolledNum", Constant(polledNum))
.SetProperty(Ref("impl"), "StreamNum", Constant(streamNum))
.SetProperty(
Ref("impl"),
"OuterJoinEqualsEval",
outerJoinEqualsEval == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
outerJoinEqualsEval.Forge,
method,
GetType(),
classScope))
.SetProperty(
Ref("impl"),
"LookupStrategy",
historicalIndexLookupStrategy.Make(method, symbols, classScope))
.SetProperty(
Ref("impl"),
"IndexingStrategy",
pollResultIndexingStrategy.Make(method, symbols, classScope))
.SetProperty(Ref("impl"), "IsAllHistoricalNoSubordinate", Constant(isAllHistoricalNoSubordinate))
.SetProperty(Ref("impl"), "IsOuterJoinPerStream", Constant(outerJoinPerStream));
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(Implementation(), this.GetType(), classScope);
method.Block
.DeclareVar(Implementation(), "impl", NewInstance(Implementation()))
.SetProperty(
Ref("impl"),
"StreamTypes",
EventTypeUtility.ResolveTypeArrayCodegen(streamTypes, symbols.GetAddInitSvc(method)))
.SetProperty(Ref("impl"), "OuterJoins", Constant(outerJoins));
if (postJoinEvaluator != null) {
method.Block.SetProperty(
Ref("impl"),
"PostJoinFilterEvaluator",
ExprNodeUtilityCodegen.CodegenEvaluatorNoCoerce(
postJoinEvaluator.Forge,
method,
this.GetType(),
classScope));
}
PopulateInline(Ref("impl"), method, symbols, classScope);
method.Block.MethodReturn(Ref("impl"));
return LocalMethod(method);
}
internal static CodegenExpression OptionalEvaluator(
ExprNode node,
CodegenMethod method,
CodegenClassScope classScope)
{
return node == null ? ConstantNull() : ExprNodeUtilityCodegen.CodegenEvaluator(node.Forge, method, typeof(FilterSpecPlanForge), classScope);
}
public override CodegenExpression Make(
Type optCoercionType,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(QueryGraphValueEntryRange), GetType(), classScope);
method.Block
.DeclareVar<ExprEvaluator>(
"start",
ExprNodeUtilityCodegen.CodegenEvaluatorWCoerce(
ExprStart.Forge,
optCoercionType,
method,
GetType(),
classScope))
.DeclareVar<ExprEvaluator>(
"end",
ExprNodeUtilityCodegen.CodegenEvaluatorWCoerce(
ExprEnd.Forge,
optCoercionType,
method,
GetType(),
classScope))
.MethodReturn(
NewInstance<QueryGraphValueEntryRangeIn>(
EnumValue(typeof(QueryGraphRangeEnum), type.GetName()),
Ref("start"),
Ref("end"),
Constant(IsAllowRangeReversal)));
return LocalMethod(method);
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(StatementAgentInstanceFactoryCreateVariable), GetType(), classScope);
method.Block
.DeclareVar<StatementAgentInstanceFactoryCreateVariable>(
"saiff",
NewInstance(typeof(StatementAgentInstanceFactoryCreateVariable)))
.SetProperty(
Ref("saiff"), "VariableName", Constant(variableName))
.SetProperty(
Ref("saiff"),
"ResultSetProcessorFactoryProvider",
NewInstanceInner(resultSetProcessorProviderClassName, symbols.GetAddInitSvc(method), Ref("statementFields")));
if (optionalInitialValue != null) {
method.Block
.SetProperty(
Ref("saiff"),
"VariableInitialValueExpr",
ExprNodeUtilityCodegen.CodegenEvaluator(optionalInitialValue, method, GetType(), classScope))
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method)).Add("AddReadyCallback", Ref("saiff")));
}
method.Block.MethodReturn(Ref("saiff"));
return method;
}
private static CodegenExpression MakeAssignments(
ExprAssignment[] assignments,
VariableMetaData[] variables,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(VariableTriggerSetDesc[]), typeof(VariableReadWritePackageForge), classScope);
method.Block.DeclareVar <VariableTriggerSetDesc[]>("sets", NewArrayByLength(typeof(VariableTriggerSetDesc), Constant(assignments.Length)));
for (var i = 0; i < assignments.Length; i++)
{
CodegenExpression set;
if (assignments[i] is ExprAssignmentStraight)
{
var straightAssignment = (ExprAssignmentStraight)assignments[i];
set = NewInstance <VariableTriggerSetDesc>(
Constant(straightAssignment.Lhs.FullIdentifier),
ExprNodeUtilityCodegen.CodegenEvaluator(straightAssignment.Rhs.Forge, method, typeof(VariableReadWritePackageForge), classScope));
}
else
{
set = NewInstance <VariableTriggerSetDesc>(Constant(variables[i].VariableName), ConstantNull());
}
method.Block.AssignArrayElement("sets", Constant(i), set);
}
method.Block.MethodReturn(Ref("sets"));
return(LocalMethod(method));
}
protected override void MakeInlineSpecificSetter(
CodegenExpressionRef queryMethod,
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block.SetProperty(
queryMethod,
"OptionalWhereClause",
whereClause == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(whereClause.Forge, method, this.GetType(), classScope));
if (processor is FireAndForgetProcessorNamedWindowForge) {
method.Block.SetProperty(
queryMethod,
"UpdateHelperNamedWindow",
updateHelper.MakeWCopy(method, classScope));
}
else {
FireAndForgetProcessorTableForge table = (FireAndForgetProcessorTableForge) processor;
method.Block
.SetProperty(queryMethod, "UpdateHelperTable", updateHelper.MakeNoCopy(method, classScope))
.SetProperty(
queryMethod,
"Table",
TableDeployTimeResolver.MakeResolveTable(table.Table, symbols.GetAddInitSvc(method)));
}
}
private static CodegenExpression CodegenMultikeyGetterBeanGet(
EventPropertyGetterSPI[] getters,
Type[] getterResultTypes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethod method,
CodegenClassScope classScope)
{
var get = new CodegenExpressionLambda(method.Block)
.WithParams(CodegenNamedParam.From(typeof(EventBean), "bean"));
var lambda = NewInstance <ProxyEventPropertyValueGetter>(get);
var expressions = new CodegenExpression[getters.Length];
for (var i = 0; i < getters.Length; i++)
{
expressions[i] = getters[i].EventBeanGetCodegen(Ref("bean"), method, classScope);
var mkType = multiKeyClassRef.MKTypes[i];
var getterType = getterResultTypes[i];
expressions[i] = ExprNodeUtilityCodegen.CodegenCoerce(expressions[i], getterType, mkType, true);
}
var instance = multiKeyClassRef.ClassNameMK.Type != null
? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions)
: NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions);
get.Block.BlockReturn(instance);
return(lambda);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(InternalEventRouterDesc), GetType(), classScope);
var eventTypeExpr = EventTypeUtility.ResolveTypeCodegen(eventType, symbols.GetAddInitSvc(method));
var optionalWhereClauseExpr = optionalWhereClause == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
optionalWhereClause.Forge,
method,
GetType(),
classScope);
var assignmentsExpr = ExprNodeUtilityCodegen.CodegenEvaluators(assignments, method, GetType(), classScope);
var writersExpr = MakeWriters(writers, method, symbols, classScope);
method.Block
.DeclareVar<InternalEventRouterDesc>("ire", NewInstance(typeof(InternalEventRouterDesc)))
.SetProperty(Ref("ire"), "Wideners", MakeWideners(wideners, method, classScope))
.SetProperty(Ref("ire"), "EventType", eventTypeExpr)
.SetProperty(Ref("ire"), "OptionalWhereClauseEval", optionalWhereClauseExpr)
.SetProperty(Ref("ire"), "Properties", Constant(properties))
.SetProperty(Ref("ire"), "Assignments", assignmentsExpr)
.SetProperty(Ref("ire"), "Writers", writersExpr)
.MethodReturn(Ref("ire"));
return LocalMethod(method);
}
public CodegenExpression MakeEvaluator(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(TimePeriodComputeNCGivenTPCalForgeEval), GetType(), classScope);
method.Block
.DeclareVar<TimePeriodComputeNCGivenTPCalForgeEval>(
"eval",
NewInstance(typeof(TimePeriodComputeNCGivenTPCalForgeEval)))
.SetProperty(
Ref("eval"),
"Adders",
TimePeriodAdderUtil.MakeArray(timePeriodForge.Adders, parent, classScope))
.SetProperty(
Ref("eval"),
"Evaluators",
ExprNodeUtilityCodegen.CodegenEvaluators(timePeriodForge.Forges, method, GetType(), classScope))
.SetProperty(Ref("eval"), "TimeAbacus", classScope.AddOrGetDefaultFieldSharable(TimeAbacusField.INSTANCE))
.SetProperty(
Ref("eval"),
"TimeZone",
classScope.AddOrGetDefaultFieldSharable(RuntimeSettingsTimeZoneField.INSTANCE))
.SetProperty(Ref("eval"), "IndexMicroseconds", Constant(indexMicroseconds))
.MethodReturn(Ref("eval"));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(
typeof(SubordInKeywordSingleTableLookupStrategyFactory),
GetType(),
classScope);
var expressions = new string[exprNodes.Count];
method.Block.DeclareVar<ExprEvaluator[]>(
"evals",
NewArrayByLength(typeof(ExprEvaluator), Constant(exprNodes.Count)));
for (var i = 0; i < exprNodes.Count; i++) {
CodegenExpression eval = ExprNodeUtilityCodegen.CodegenEvaluatorNoCoerce(
exprNodes[i].Forge,
method,
GetType(),
classScope);
method.Block.AssignArrayElement(Ref("evals"), Constant(i), eval);
expressions[i] = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprNodes[i]);
}
method.Block.MethodReturn(
NewInstance<SubordInKeywordSingleTableLookupStrategyFactory>(
Constant(_isNwOnTrigger),
Constant(_streamCountOuter),
Ref("evals"),
Constant(expressions)));
return LocalMethod(method);
}
public CodegenExpression CodegenCreateReader(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(AggregationTAAReaderLinearFirstLastIndex), GetType(), classScope);
method.Block
.DeclareVar<AggregationTAAReaderLinearFirstLastIndex>(
"strat",
NewInstance(typeof(AggregationTAAReaderLinearFirstLastIndex)))
.SetProperty(Ref("strat"), "AccessType", Constant(accessType))
.SetProperty(Ref("strat"), "OptionalConstIndex", Constant(optionalConstant))
.SetProperty(
Ref("strat"),
"OptionalIndexEval",
optionalIndexEval == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
optionalIndexEval.Forge,
method,
GetType(),
classScope))
.MethodReturn(Ref("strat"));
return LocalMethod(method);
}
public CodegenExpression CodegenMake(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent.MakeChild(
typeof(EventAdvancedIndexProvisionRuntime),
typeof(EventAdvancedIndexProvisionCompileTime),
classScope);
var indexExpressions =
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceAsArray(IndexDesc.IndexedExpressions);
var indexProperties = GetPropertiesPerExpressionExpectSingle(IndexDesc.IndexedExpressions);
method.Block
.DeclareVar<EventAdvancedIndexProvisionRuntime>(
"desc",
NewInstance(typeof(EventAdvancedIndexProvisionRuntime)))
.SetProperty(Ref("desc"), "IndexExpressionTexts", Constant(indexExpressions))
.SetProperty(Ref("desc"), "IndexProperties", Constant(indexProperties))
.SetProperty(
Ref("desc"),
"IsIndexExpressionsAllProps",
Constant(IsExpressionsAllPropsOnly(IndexDesc.IndexedExpressions)))
.SetProperty(Ref("desc"), "Factory", Factory.CodegenMake(parent, classScope))
.SetProperty(
Ref("desc"),
"ParameterExpressionTexts",
Constant(ExprNodeUtilityPrint.ToExpressionStringsMinPrecedence(Parameters)))
.SetProperty(
Ref("desc"),
"ParameterEvaluators",
ExprNodeUtilityCodegen.CodegenEvaluators(Parameters, parent, GetType(), classScope))
.SetProperty(Ref("desc"), "ConfigStatement", ConfigStatement.CodegenMake(parent, classScope))
.SetProperty(Ref("desc"), "IndexTypeName", Constant(IndexDesc.IndexTypeName))
.MethodReturn(Ref("desc"));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
return NewInstance<OutputConditionPolledCrontabFactory>(
ExprNodeUtilityCodegen.CodegenEvaluators(expressions, parent, this.GetType(), classScope));
}
public override CodegenExpression Codegen(
InternalEventRouterWriterForge writer,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent
.MakeChild(typeof(InternalEventRouterWriterArrayElement), GetType(), classScope);
var indexExpr = ExprNodeUtilityCodegen.CodegenEvaluator(
_indexExpression.Forge,
method,
typeof(VariableTriggerWriteArrayElementForge),
classScope);
var rhsExpr = ExprNodeUtilityCodegen.CodegenEvaluator(
_rhsExpression.Forge,
method,
typeof(VariableTriggerWriteArrayElementForge),
classScope);
var typeWidenerExpr = _widener == null
? ConstantNull()
: TypeWidenerFactory.CodegenWidener(_widener, method, GetType(), classScope);
method.Block
.DeclareVar <InternalEventRouterWriterArrayElement>("desc", NewInstance(typeof(InternalEventRouterWriterArrayElement)))
.SetProperty(Ref("desc"), "IndexExpression", indexExpr)
.SetProperty(Ref("desc"), "RhsExpression", rhsExpr)
.SetProperty(Ref("desc"), "TypeWidener", typeWidenerExpr)
.SetProperty(Ref("desc"), "PropertyName", Constant(_propertyName))
.MethodReturn(Ref("desc"));
return(LocalMethod(method));
}
public CodegenExpression CodegenCreateReader(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(AggregationMultiFunctionAggregationMethod), GetType(), classScope);
method.Block
.DeclareVar <ExprEvaluator>("fromKeyEval", ExprNodeUtilityCodegen.CodegenEvaluator(_fromKey.Forge, method, GetType(), classScope))
.DeclareVar(
typeof(ExprEvaluator),
"fromInclusiveEval",
ExprNodeUtilityCodegen.CodegenEvaluator(_fromInclusive.Forge, method, GetType(), classScope))
.DeclareVar <ExprEvaluator>("toKeyEval", ExprNodeUtilityCodegen.CodegenEvaluator(_toKey.Forge, method, GetType(), classScope))
.DeclareVar(
typeof(ExprEvaluator),
"toInclusiveEval",
ExprNodeUtilityCodegen.CodegenEvaluator(_toInclusive.Forge, method, GetType(), classScope))
.MethodReturn(
StaticMethod(
typeof(AggregationMethodSortedSubmapFactory),
"MakeSortedAggregationSubmap",
Ref("fromKeyEval"),
Ref("fromInclusiveEval"),
Ref("toKeyEval"),
Ref("toInclusiveEval"),
EnumValue(typeof(AggregationMethodSortedEnum), _aggMethod.GetName()),
Constant(_underlyingClass)));
return(LocalMethod(method));
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(QueryGraphValueEntryCustomOperation), GetType(), classScope);
method.Block.DeclareVar<IDictionary<int, ExprEvaluator>>(
"map",
NewInstance(typeof(Dictionary<int, ExprEvaluator>)));
foreach (var entry in PositionalExpressions) {
method.Block.ExprDotMethod(
Ref("map"),
"Put",
Constant(entry.Key),
ExprNodeUtilityCodegen.CodegenEvaluator(entry.Value.Forge, method, GetType(), classScope));
}
method.Block
.DeclareVar<QueryGraphValueEntryCustomOperation>(
"op",
NewInstance(typeof(QueryGraphValueEntryCustomOperation)))
.SetProperty(Ref("op"), "PositionalExpressions", Ref("map"))
.MethodReturn(Ref("op"));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
// initialize+resolve variables
var symbols = new SAIFFInitializeSymbol();
var variableInit = classScope.NamespaceScope
.InitMethod
.MakeChildWithScope(typeof(VariableReadWritePackage), this.GetType(), symbols, classScope)
.AddParam(typeof(EPStatementInitServices), EPStatementInitServicesConstants.REF.Ref);
variableInit.Block
.MethodReturn(variableReadWritePackage.Make(variableInit, symbols, classScope));
var variableRW = classScope.NamespaceScope.AddDefaultFieldUnshared(
true,
typeof(VariableReadWritePackage),
LocalMethod(variableInit, EPStatementInitServicesConstants.REF));
var method = parent.MakeChild(typeof(OutputConditionPolledExpressionFactory), this.GetType(), classScope);
method.Block
.DeclareVar<OutputConditionPolledExpressionFactory>(
"factory",
NewInstance(typeof(OutputConditionPolledExpressionFactory)))
.SetProperty(
Ref("factory"),
"WhenExpression",
ExprNodeUtilityCodegen.CodegenEvaluator(whenExpressionNode, method, this.GetType(), classScope))
.SetProperty(Ref("factory"), "VariableReadWritePackage", variableRW)
.SetProperty(Ref("factory"), "IsUsingBuiltinProperties", Constant(isUsingBuiltinProperties))
.MethodReturn(Ref("factory"));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
if (scheduleCallbackId == -1) {
throw new IllegalStateException("Unassigned schedule");
}
var method = parent.MakeChild(typeof(OutputConditionFactory), GetType(), classScope);
method.Block.DeclareVar<ExprEvaluator[]>(
"evals",
NewArrayByLength(typeof(ExprEvaluator), Constant(scheduleSpecEvaluators.Length)));
for (var i = 0; i < scheduleSpecEvaluators.Length; i++) {
method.Block.AssignArrayElement(
"evals",
Constant(i),
ExprNodeUtilityCodegen.CodegenEvaluatorNoCoerce(
scheduleSpecEvaluators[i],
method,
GetType(),
classScope));
}
method.Block.MethodReturn(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPStatementInitServicesConstants.RESULTSETPROCESSORHELPERFACTORY)
.Add(
"MakeOutputConditionCrontab",
Ref("evals"),
Constant(isStartConditionOnCreation),
Constant(scheduleCallbackId)));
return LocalMethod(method);
}
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);
}
protected CodegenExpression MakeFilter(
CodegenMethod method,
CodegenClassScope classScope)
{
return OptionalFilter == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(OptionalFilter.Forge, method, GetType(), classScope);
}
public CodegenExpression Make(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
return NewInstance<AggregationAgentDefaultWFilter>(
ExprNodeUtilityCodegen.CodegenEvaluator(filterEval, method, this.GetType(), classScope));
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(
typeof(StatementAgentInstanceFactoryCreateNW),
this.GetType(),
classScope);
method.Block
.DeclareVar<StatementAgentInstanceFactoryCreateNW>(
"saiff",
NewInstance(typeof(StatementAgentInstanceFactoryCreateNW)));
method.Block
.SetProperty(Ref("saiff"), "Activator", activator.MakeCodegen(method, symbols, classScope))
.SetProperty(Ref("saiff"), "NamedWindowName", Constant(namedWindowName))
.SetProperty(
Ref("saiff"),
"ViewFactories",
ViewFactoryForgeUtil.CodegenForgesWInit(views, 0, null, method, symbols, classScope))
.SetProperty(
Ref("saiff"),
"InsertFromNamedWindow",
insertFromNamedWindow == null
? ConstantNull()
: NamedWindowDeployTimeResolver.MakeResolveNamedWindow(
insertFromNamedWindow,
symbols.GetAddInitSvc(method)))
.SetProperty(
Ref("saiff"),
"InsertFromFilter",
insertFromFilter == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
insertFromFilter.Forge,
method,
this.GetType(),
classScope))
.SetProperty(
Ref("saiff"),
"AsEventType",
asEventType == null
? ConstantNull()
: EventTypeUtility.ResolveTypeCodegen(asEventType, EPStatementInitServicesConstants.REF))
.SetProperty(
Ref("saiff"),
"ResultSetProcessorFactoryProvider",
NewInstance(
resultSetProcessorProviderClassName,
symbols.GetAddInitSvc(method),
Ref("statementFields")))
.ExprDotMethod(symbols.GetAddInitSvc(method), "AddReadyCallback", Ref("saiff"));
method.Block.MethodReturn(Ref("saiff"));
return method;
}
public CodegenExpression Make(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
return NewInstance<AggregationAgentRewriteStreamWFilter>(
Constant(_streamNum),
ExprNodeUtilityCodegen.CodegenEvaluator(_filterEval, method, this.GetType(), classScope));
}
public override CodegenExpression EvaluateCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpression aggService = classScope.NamespaceScope.AddOrGetDefaultFieldWellKnown(
new CodegenFieldNameSubqueryAgg(subselect.SubselectNumber),
typeof(AggregationResultFuture));
var method = parent.MakeChild(subselect.EvaluationType, this.GetType(), classScope);
var evalCtx = symbols.GetAddExprEvalCtx(method);
method.Block
.DeclareVar<int>("cpid", ExprDotName(evalCtx, "AgentInstanceId"))
.DeclareVar<ICollection<object>>(
"groupKeys",
ExprDotMethod(aggService, "GetGroupKeys", evalCtx))
.IfCondition(Not(EqualsIdentity(ExprDotName(Ref("groupKeys"), "Count"), Constant(1))))
.BlockReturn(ConstantNull())
.ExprDotMethod(
aggService,
"SetCurrentAccess",
ExprDotMethodChain(Ref("groupKeys")).Add("First"),
Ref("cpid"),
ConstantNull())
.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols)
.AssignArrayElement(
REF_EVENTS_SHIFTED,
Constant(0),
StaticMethod(
typeof(EventBeanUtility),
"GetNonemptyFirstEvent",
symbols.GetAddMatchingEvents(method)));
if (subselect.SelectClause.Length == 1) {
var eval = CodegenLegoMethodExpression.CodegenExpression(subselect.SelectClause[0].Forge, method, classScope, true);
method.Block.MethodReturn(
LocalMethod(eval, REF_EVENTS_SHIFTED, ConstantTrue(), symbols.GetAddExprEvalCtx(method)));
}
else {
var methodSelect = ExprNodeUtilityCodegen.CodegenMapSelect(
subselect.SelectClause,
subselect.SelectAsNames,
this.GetType(),
method,
classScope);
CodegenExpression select = LocalMethod(
methodSelect,
REF_EVENTS_SHIFTED,
ConstantTrue(),
symbols.GetAddExprEvalCtx(method));
method.Block.MethodReturn(select);
}
return LocalMethod(method);
}
public SAIFFInitializeBuilder Forges(
string name,
ExprForge[] evaluatorForges)
{
return SetValue(
name,
evaluatorForges == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluators(evaluatorForges, method, originator, classScope));
}
public SAIFFInitializeBuilder Exprnode(
string name,
ExprNode value)
{
return SetValue(
name,
value == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(value.Forge, method, GetType(), classScope));
}
internal override void Assign(
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var sizeEval = ExprNodeUtilityCodegen
.CodegenEvaluator(sizeForge, method, this.GetType(), classScope);
method.Block.SetProperty(factory, "SizeEvaluator", sizeEval);
}
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",
NewInstance(_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))
.MethodReturn(select);
}
