public override void InlineInitializeOnTriggerBase(
CodegenExpressionRef saiff,
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block
.SetProperty(
saiff,
"NamedWindow",
namedWindow == null
? ConstantNull()
: NamedWindowDeployTimeResolver.MakeResolveNamedWindow(
namedWindow,
symbols.GetAddInitSvc(method)))
.SetProperty(
saiff,
"Table",
table == null
? ConstantNull()
: TableDeployTimeResolver.MakeResolveTable(table, symbols.GetAddInitSvc(method)))
.SetProperty(saiff, "QueryPlan", queryPlanForge.Make(method, symbols, classScope))
.SetProperty(
saiff,
"NonSelectRSPFactoryProvider",
nonSelectRSPProviderClassName == null
? ConstantNull()
: NewInstanceInner(nonSelectRSPProviderClassName, symbols.GetAddInitSvc(method), Ref("statementFields")))
.ExprDotMethod(symbols.GetAddInitSvc(method), "AddReadyCallback", saiff); // add ready-callback
InlineInitializeOnTriggerSpecific(saiff, method, symbols, classScope);
}
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);
}
public override CodegenExpression EvaluateCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
var eventToPublic = TableDeployTimeResolver.MakeTableEventToPublicField(table, classScope, GetType());
var method = parent.MakeChild(subselect.EvaluationType, GetType(), classScope);
method.Block
.IfCondition(
Relational(
ExprDotName(symbols.GetAddMatchingEvents(method), "Count"),
CodegenExpressionRelational.CodegenRelational.GT,
Constant(1)))
.BlockReturn(ConstantNull())
.DeclareVar<EventBean>(
"@event",
StaticMethod(
typeof(EventBeanUtility),
"GetNonemptyFirstEvent",
symbols.GetAddMatchingEvents(method)))
.MethodReturn(
ExprDotMethod(
eventToPublic,
"ConvertToUnd",
Ref("@event"),
symbols.GetAddEPS(method),
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
return LocalMethod(method);
}
public CodegenExpression Codegen(
CodegenExpression inner,
Type innerType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenExpression eventToPublic = TableDeployTimeResolver.MakeTableEventToPublicField(
tableMetadata,
codegenClassScope,
this.GetType());
CodegenMethod methodNode = codegenMethodScope
.MakeChild(typeof(object[]), typeof(ExprDotForgeUnpackBeanTable), codegenClassScope)
.AddParam(typeof(EventBean), "target");
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
CodegenExpression refIsNewData = exprSymbol.GetAddIsNewData(methodNode);
CodegenExpressionRef refExprEvalCtx = exprSymbol.GetAddExprEvalCtx(methodNode);
methodNode.Block
.IfRefNullReturnNull("target")
.MethodReturn(
ExprDotMethod(eventToPublic, "ConvertToUnd", Ref("target"), refEPS, refIsNewData, refExprEvalCtx));
return LocalMethod(methodNode, inner);
}
public CodegenExpression MakeProvider(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(AggregationServiceFactoryTable), this.GetType(), classScope);
method.Block
.DeclareVar<AggregationServiceFactoryTable>(
"factory",
NewInstance(typeof(AggregationServiceFactoryTable)))
.SetProperty(
Ref("factory"),
"Table",
TableDeployTimeResolver.MakeResolveTable(metadata, symbols.GetAddInitSvc(method)))
.SetProperty(
Ref("factory"),
"MethodPairs",
TableColumnMethodPairForge.MakeArray(methodPairs, method, symbols, classScope))
.SetProperty(Ref("factory"), "AccessColumnsZeroOffset", Constant(accessColumnsZeroOffset))
.SetProperty(
Ref("factory"),
"AccessAgents",
AggregationAgentUtil.MakeArray(accessAgents, method, symbols, classScope))
.SetProperty(
Ref("factory"),
"GroupByRollupDesc",
groupByRollupDesc == null ? ConstantNull() : groupByRollupDesc.Codegen(method, classScope))
.MethodReturn(Ref("factory"));
return LocalMethod(method);
}
public void GetValueCodegen(AggregationAccessorForgeGetCodegenContext context)
{
var eventToPublic =
TableDeployTimeResolver.MakeTableEventToPublicField(table, context.ClassScope, GetType());
var sorted = (AggregatorAccessSorted) context.AccessStateForge.Aggregator;
var size = sorted.SizeCodegen();
var enumerator = max ? sorted.ReverseEnumeratorCodegen() : sorted.EnumeratorCodegen();
context.Method.Block.IfCondition(EqualsIdentity(size, Constant(0)))
.BlockReturn(ConstantNull())
.DeclareVar(TypeHelper.GetArrayType(componentType), "array", NewArrayByLength(componentType, size))
.DeclareVar<int>("count", Constant(0))
.DeclareVar<IEnumerator<EventBean>>("enumerator", enumerator)
.WhileLoop(ExprDotMethod(Ref("enumerator"), "MoveNext"))
.DeclareVar<EventBean>("bean", Cast(typeof(EventBean), ExprDotName(Ref("enumerator"), "Current")))
.AssignArrayElement(
Ref("array"),
Ref("count"),
ExprDotMethod(
eventToPublic,
"ConvertToUnd",
Ref("bean"),
REF_EPS,
REF_ISNEWDATA,
REF_EXPREVALCONTEXT))
.IncrementRef("count")
.BlockEnd()
.MethodReturn(Ref("array"));
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(FireAndForgetProcessorTable), GetType(), classScope);
var nw = Ref("tbl");
method.Block
.DeclareVar<FireAndForgetProcessorTable>(
nw.Ref,
NewInstance(typeof(FireAndForgetProcessorTable)))
.SetProperty(
nw,
"Table",
TableDeployTimeResolver.MakeResolveTable(Table, symbols.GetAddInitSvc(method)))
.MethodReturn(nw);
return LocalMethod(method);
}
public override CodegenExpression EvaluateCodegen(
CodegenMethodScope parent,
ExprSubselectEvalMatchSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpressionInstanceField eventToPublic =
TableDeployTimeResolver.MakeTableEventToPublicField(table, classScope, this.GetType());
CodegenMethod method = parent.MakeChild(subselect.EvaluationType, this.GetType(), classScope);
method.Block.ApplyTri(DECLARE_EVENTS_SHIFTED, method, symbols);
method.Block.DeclareVar<EventBean>("filtered", ConstantNull());
CodegenBlock @foreach = method.Block.ForEach(
typeof(EventBean),
"@event",
symbols.GetAddMatchingEvents(method));
{
@foreach.AssignArrayElement(REF_EVENTS_SHIFTED, Constant(0), Ref("@event"));
CodegenMethod filter = CodegenLegoMethodExpression.CodegenExpression(subselect.FilterExpr, method, classScope, true);
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
@foreach,
typeof(bool?),
LocalMethod(
filter,
REF_EVENTS_SHIFTED,
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
@foreach.IfCondition(NotEqualsNull(Ref("filtered")))
.BlockReturn(ConstantNull())
.AssignRef("filtered", Ref("@event"));
}
method.Block.IfRefNullReturnNull("filtered")
.MethodReturn(
ExprDotMethod(
eventToPublic,
"ConvertToUnd",
Ref("filtered"),
symbols.GetAddEPS(method),
symbols.GetAddIsNewData(method),
symbols.GetAddExprEvalCtx(method)));
return LocalMethod(method);
}
public CodegenExpression Make(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var resolveTable = table == null
? ConstantNull()
: TableDeployTimeResolver.MakeResolveTable(table, symbols.GetAddInitSvc(method));
var insertIntoStreamSelectorExpr = insertIntoStreamSelector == null
? ConstantNull()
: EnumValue(typeof(SelectClauseStreamSelectorEnum), insertIntoStreamSelector.Value.GetName());
return NewInstance<OutputStrategyPostProcessFactory>(
Constant(isRouted),
insertIntoStreamSelectorExpr,
EnumValue(typeof(SelectClauseStreamSelectorEnum), selectStreamSelector.GetName()),
Constant(routeToFront),
resolveTable);
}
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 void GetValueCodegen(AggregationAccessorForgeGetCodegenContext context)
{
var eventToPublic =
TableDeployTimeResolver.MakeTableEventToPublicField(table, context.ClassScope, GetType());
var forge = (AggregatorAccessSorted) context.AccessStateForge.Aggregator;
context.Method.Block.DeclareVar<EventBean>(
"@event",
max
? forge.GetLastValueCodegen(context.ClassScope, context.Method)
: forge.GetFirstValueCodegen(context.ClassScope, context.Method))
.IfRefNullReturnNull("@event")
.MethodReturn(
ExprDotMethod(
eventToPublic,
"ConvertToUnd",
Ref("@event"),
REF_EPS,
REF_ISNEWDATA,
REF_EXPREVALCONTEXT));
}
public CodegenExpression EvaluateCodegenUninstrumented(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenExpressionRef refEps = exprSymbol.GetAddEPS(codegenMethodScope);
CodegenExpression refIsNewData = exprSymbol.GetAddIsNewData(codegenMethodScope);
CodegenExpressionRef refExprEvalCtx = exprSymbol.GetAddExprEvalCtx(codegenMethodScope);
CodegenExpressionInstanceField eventToPublic =
TableDeployTimeResolver.MakeTableEventToPublicField(_tableMetadata, codegenClassScope, this.GetType());
return StaticMethod(
typeof(ExprEvalStreamInsertTable),
"ConvertToTableEvent",
Constant(_streamNum),
eventToPublic,
refEps,
refIsNewData,
refExprEvalCtx);
}
public CodegenExpression Codegen(
CodegenExpression inner,
Type innerType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var eventToPublic =
TableDeployTimeResolver.MakeTableEventToPublicField(table, codegenClassScope, this.GetType());
var refEPS = exprSymbol.GetAddEPS(codegenMethodScope);
var refIsNewData = exprSymbol.GetAddIsNewData(codegenMethodScope);
var refExprEvalCtx = exprSymbol.GetAddExprEvalCtx(codegenMethodScope);
return StaticMethod(
typeof(ExprDotForgeUnpackCollEventBeanTable),
"ConvertToTableUnderling",
inner,
eventToPublic,
refEPS,
refIsNewData,
refExprEvalCtx);
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(
typeof(StatementAgentInstanceFactoryCreateIndex),
this.GetType(),
classScope);
CodegenExpressionRef saiff = Ref("saiff");
method.Block
.DeclareVar<StatementAgentInstanceFactoryCreateIndex>(
saiff.Ref,
NewInstance(typeof(StatementAgentInstanceFactoryCreateIndex)))
.SetProperty(
saiff,
"EventType",
EventTypeUtility.ResolveTypeCodegen(eventType, symbols.GetAddInitSvc(method)))
.SetProperty(saiff, "IndexName", Constant(indexName))
.SetProperty(saiff, "IndexModuleName", Constant(indexModuleName))
.SetProperty(saiff, "IndexMultiKey", imk.Make(method, classScope))
.SetProperty(saiff, "ExplicitIndexDesc", explicitIndexDesc.Make(method, classScope));
if (namedWindow != null) {
method.Block.SetProperty(
saiff,
"NamedWindow",
NamedWindowDeployTimeResolver.MakeResolveNamedWindow(namedWindow, symbols.GetAddInitSvc(method)));
}
else {
method.Block.SetProperty(
saiff,
"Table",
TableDeployTimeResolver.MakeResolveTable(table, symbols.GetAddInitSvc(method)));
}
method.Block.MethodReturn(saiff);
return method;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenExpressionInstanceField eventToPublic =
TableDeployTimeResolver.MakeTableEventToPublicField(table, codegenClassScope, this.GetType());
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
CodegenExpression refIsNewData = exprSymbol.GetAddIsNewData(methodNode);
CodegenExpressionRef refExprEvalCtx = exprSymbol.GetAddExprEvalCtx(methodNode);
methodNode.Block
.DeclareVar<EventBean>("@event", ArrayAtIndex(refEPS, Constant(0)))
.IfRefNullReturnNull("@event")
.MethodReturn(
ExprDotMethod(eventToPublic, "Convert", Ref("@event"), refEPS, refIsNewData, refExprEvalCtx));
return methodNode;
}
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 override CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var size = context.ExprForges.Length +
namedStreams.Count +
(isUsingWildcard && context.NumStreams > 1 ? context.NumStreams : 0);
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
var refIsNewData = exprSymbol.GetAddIsNewData(methodNode);
var refExprEvalCtx = exprSymbol.GetAddExprEvalCtx(methodNode);
var init = size == 0
? StaticMethod(typeof(Collections), "GetEmptyMap", new[] { typeof(string), typeof(object) })
: NewInstance(typeof(HashMap<string, object>));
var block = methodNode.Block
.DeclareVar<IDictionary<string, object>>("props", init);
var count = 0;
foreach (var forge in context.ExprForges) {
block.Expression(
ExprDotMethod(
Ref("props"),
"Put",
Constant(context.ColumnNames[count]),
CodegenLegoMayVoid.ExpressionMayVoid(
typeof(object),
forge,
methodNode,
exprSymbol,
codegenClassScope)));
count++;
}
foreach (var element in namedStreams) {
var theEvent = ArrayAtIndex(refEPS, Constant(element.StreamNumber));
if (element.TableMetadata != null) {
var eventToPublic = TableDeployTimeResolver.MakeTableEventToPublicField(
element.TableMetadata,
codegenClassScope,
GetType());
theEvent = ExprDotMethod(eventToPublic, "Convert", theEvent, refEPS, refIsNewData, refExprEvalCtx);
}
block.Expression(ExprDotMethod(Ref("props"), "Put", Constant(context.ColumnNames[count]), theEvent));
count++;
}
if (isUsingWildcard && context.NumStreams > 1) {
for (var i = 0; i < context.NumStreams; i++) {
block.Expression(
ExprDotMethod(
Ref("props"),
"Put",
Constant(context.ColumnNames[count]),
ArrayAtIndex(refEPS, Constant(i))));
count++;
}
}
block.MethodReturn(
ProcessSpecificCodegen(
resultEventType,
eventBeanFactory,
Ref("props"),
methodNode,
exprSymbol,
codegenClassScope));
return methodNode;
}
