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);
        }
Пример #2
0
 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);
 }
Пример #4
0
        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);
        }
Пример #5
0
 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"));
        }
Пример #7
0
 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);
 }
Пример #8
0
        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);
        }
Пример #9
0
 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));
        }
Пример #11
0
 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));
 }
Пример #12
0
 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);
 }
Пример #13
0
 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);
 }
Пример #14
0
        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;
        }
Пример #15
0
 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;
 }
Пример #16
0
 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)));
 }
Пример #17
0
        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;
        }