public CodegenExpression make(CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenExpression childNodeArray = CodegenMakeableUtil.makeArray("childNodes", QueryPlanNode.class, childNodes.toArray(new QueryPlanNodeForge[childNodes.size()]), this.getClass(), parent, symbols, classScope); return newInstance(NestedIterationNode.class, childNodeArray, constant(nestingOrder)); }
public CodegenExpression make(CodegenExpressionRef addInitSvc) { CodegenExpression[] init = new CodegenExpression[items.length]; for (int i = 0; i < init.length; i++) { init[i] = items[i].make(addInitSvc); } return newInstance(ContextControllerHashValidation.class, newArrayWithInit(ContextControllerHashValidationItem.class, init)); }
public AggregatorRateEver(AggregationForgeFactoryRate factory, int col, CodegenCtor rowCtor, CodegenMemberCol membersColumnized, CodegenClassScope classScope, Class optionalDistinctValueType, boolean hasFilter, ExprNode optionalFilter) { super(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, hasFilter, optionalFilter); this.factory = factory; points = membersColumnized.addMember(col, Deque.class, "points"); hasLeave = membersColumnized.addMember(col, boolean.class, "hasLeave"); rowCtor.getBlock().assignRef(points, newInstance(ArrayDeque.class)); }
public CodegenExpression codegenCreateReader(CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenMethod method = parent.makeChild(AgregationMethodCountMinSketchTopK.class, this.getClass(), classScope); method.getBlock() .declareVar(AgregationMethodCountMinSketchTopK.class, "strat", newInstance(AgregationMethodCountMinSketchTopK.class)) .methodReturn(ref("strat")); return localMethod(method); } }
public AggregatorAvgBig(AggregationForgeFactoryAvg factory, int col, CodegenCtor rowCtor, CodegenMemberCol membersColumnized, CodegenClassScope classScope, Class optionalDistinctValueType, boolean hasFilter, ExprNode optionalFilter) { super(factory, col, rowCtor, membersColumnized, classScope, optionalDistinctValueType, hasFilter, optionalFilter); this.factory = factory; sum = membersColumnized.addMember(col, BigDecimal.class, "sum"); cnt = membersColumnized.addMember(col, long.class, "cnt"); rowCtor.getBlock().assignRef(sum, newInstance(BigDecimal.class, constant(0d))); }
public CodegenExpression codegenCreateReader(CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenMethod method = parent.makeChild(AgregationMethodCountMinSketchFreq.class, this.getClass(), classScope); method.getBlock() .declareVar(AgregationMethodCountMinSketchFreq.class, "strat", newInstance(AgregationMethodCountMinSketchFreq.class)) .exprDotMethod(ref("strat"), "setFrequencyEval", ExprNodeUtilityCodegen.codegenEvaluator(frequencyEval.getForge(), method, this.getClass(), classScope)) .methodReturn(ref("strat")); return localMethod(method); } }
public CodegenExpression makeCodegen(CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenMethod method = parent.makeChild(ViewableActivatorHistorical.class, this.getClass(), classScope); method.getBlock().declareVar(ViewableActivatorHistorical.class, "hist", newInstance(ViewableActivatorHistorical.class)) .exprDotMethod(ref("hist"), "setFactory", viewableForge.make(method, symbols, classScope)) .methodReturn(ref("hist")); return localMethod(method); } }
public CodegenExpression codegenCreateReader(CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenMethod method = parent.makeChild(AggregationMethodSortedMinMaxBy.class, this.getClass(), classScope); method.getBlock() .declareVar(AggregationMethodSortedMinMaxBy.class, "strat", newInstance(AggregationMethodSortedMinMaxBy.class)) .exprDotMethod(ref("strat"), "setMax", constant(max)) .methodReturn(ref("strat")); return localMethod(method); } }
public CodegenExpression make(CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { SAIFFInitializeBuilder builder = new SAIFFInitializeBuilder(OP_PACKAGE_NAME + ".select.SelectFactory", this.getClass(), "select", parent, symbols, classScope); return builder.eventtypesMayNull("eventTypes", eventTypes) .constant("submitEventBean", submitEventBean) .constant("iterate", iterate) .constant("originatingStreamToViewableStream", originatingStreamToViewableStream) .expression("factoryProvider", newInstance(classNameAIFactoryProvider, symbols.getAddInitSvc(builder.getMethod()))) .build(); }
public CodegenExpression make(CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenMethod method = parent.makeChild(HistoricalIndexLookupStrategyHash.class, this.getClass(), classScope); method.getBlock() .declareVar(HistoricalIndexLookupStrategyHash.class, "strat", newInstance(HistoricalIndexLookupStrategyHash.class)) .exprDotMethod(ref("strat"), "setLookupStream", constant(lookupStream)) .exprDotMethod(ref("strat"), "setEvaluator", ExprNodeUtilityCodegen.codegenEvaluatorMayMultiKeyWCoerce(evaluators, coercionTypes, method, this.getClass(), classScope)) .methodReturn(ref("strat")); return localMethod(method); } }
public CodegenExpression iteratorCodegen(CodegenClassScope classScope, CodegenMethod parentMethod, CodegenNamedMethods namedMethods) { CodegenMethod initArray = initArrayCodegen(namedMethods, classScope); CodegenMethod method = parentMethod.makeChildWithScope(Iterator.class, AggregatorAccessLinearJoin.class, CodegenSymbolProviderEmpty.INSTANCE, classScope); method.getBlock().ifRefNull(array) .localMethod(initArray) .blockEnd() .methodReturn(newInstance(ArrayEventIterator.class, array)); return localMethod(method); }
public static void getIteratorJoinCodegen(ResultSetProcessorRowForAllForge forge, CodegenClassScope classScope, CodegenMethod method, CodegenInstanceAux instance) { CodegenMethod select = getSelectListEventsAsArrayCodegen(forge, classScope, instance); method.getBlock() .declareVar(EventBean[].class, "result", localMethod(select, constant(true), constantTrue(), constantTrue())) .methodReturn(newInstance(ArrayEventIterator.class, ref("result"))); }
protected void applyEvalEnterNonNull(CodegenExpressionRef value, Class valueType, CodegenMethod method, ExprForgeCodegenSymbol symbols, ExprForge[] forges, CodegenClassScope classScope) { if (valueType == BigInteger.class) { method.getBlock().assignRef(sum, exprDotMethod(sum, "add", newInstance(BigDecimal.class, value))); } else { method.getBlock().assignRef(sum, exprDotMethod(sum, "add", valueType == BigDecimal.class ? value : cast(BigDecimal.class, value))); } method.getBlock().increment(cnt); }
private static CodegenExpression makeOpBuildOrder(Set<Integer> operatorBuildOrder, CodegenMethodScope parent, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { CodegenMethod method = parent.makeChild(LinkedHashSet.class, DataflowDescForge.class, classScope); method.getBlock().declareVar(LinkedHashSet.class, "order", newInstance(LinkedHashSet.class, constant(CollectionUtil.capacityHashMap(operatorBuildOrder.size())))); for (Integer entry : operatorBuildOrder) { method.getBlock().exprDotMethod(ref("order"), "add", constant(entry)); } method.getBlock().methodReturn(ref("order")); return localMethod(method); }
public void instantiateCodegen(CodegenMethod method, CodegenClassScope classScope) { CodegenExpressionField rowLimitFactory = classScope.addFieldUnshared(true, RowLimitProcessorFactory.class, rowLimitProcessorFactoryForge.make(classScope.getPackageScope().getInitMethod(), classScope)); method.getBlock().declareVar(RowLimitProcessor.class, REF_ROWLIMITPROCESSOR.getRef(), exprDotMethod(rowLimitFactory, "instantiate", REF_AGENTINSTANCECONTEXT)) .methodReturn(CodegenExpressionBuilder.newInstance(CLASSNAME_ORDERBYPROCESSOR, ref("o"), REF_ROWLIMITPROCESSOR)); }
public void instantiateCodegen(CodegenMethod method, CodegenClassScope classScope) { CodegenExpressionField rowLimitFactory = classScope.addFieldUnshared(true, RowLimitProcessorFactory.class, rowLimitProcessorFactoryForge.make(classScope.getPackageScope().getInitMethod(), classScope)); method.getBlock().declareVar(RowLimitProcessor.class, REF_ROWLIMITPROCESSOR.getRef(), exprDotMethod(rowLimitFactory, "instantiate", REF_AGENTINSTANCECONTEXT)) .methodReturn(CodegenExpressionBuilder.newInstance(CLASSNAME_ORDERBYPROCESSOR, ref("o"), REF_ROWLIMITPROCESSOR)); }
public CodegenMethod initializeCodegen(CodegenClassScope classScope, CodegenMethodScope parent, SAIFFInitializeSymbol symbols) { CodegenMethod method = parent.makeChild(StatementAgentInstanceFactoryCreateContext.class, this.getClass(), classScope); method.getBlock() .declareVar(StatementAgentInstanceFactoryCreateContext.class, "saiff", newInstance(StatementAgentInstanceFactoryCreateContext.class)) .exprDotMethod(ref("saiff"), "setContextName", constant(contextName)) .exprDotMethod(ref("saiff"), "setStatementEventType", EventTypeUtility.resolveTypeCodegen(statementEventType, symbols.getAddInitSvc(method))) .exprDotMethod(symbols.getAddInitSvc(method), "addReadyCallback", ref("saiff")) .methodReturn(ref("saiff")); return method; } }
private static CodegenMethod obtainIteratorCodegen(ResultSetProcessorRowPerGroupForge forge, CodegenClassScope classScope, CodegenMethod parent, CodegenInstanceAux instance) { CodegenMethod iterator = parent.makeChild(Iterator.class, ResultSetProcessorRowPerGroupImpl.class, classScope).addParam(Viewable.class, NAME_VIEWABLE); if (!forge.isSorting()) { iterator.getBlock().methodReturn(newInstance(ResultSetProcessorRowPerGroupIterator.class, exprDotMethod(REF_VIEWABLE, "iterator"), ref("this"), REF_AGGREGATIONSVC, REF_AGENTINSTANCECONTEXT)); return iterator; } CodegenMethod getIteratorSorted = getIteratorSortedCodegen(forge, classScope, instance); iterator.getBlock().methodReturn(localMethod(getIteratorSorted, exprDotMethod(REF_VIEWABLE, "iterator"))); return iterator; }
protected void inlineInitializeOnTriggerSpecific(CodegenExpressionRef saiff, CodegenMethod method, SAIFFInitializeSymbol symbols, CodegenClassScope classScope) { method.getBlock() .exprDotMethod(saiff, "setResultSetProcessorFactoryProvider", CodegenExpressionBuilder.newInstance(resultSetProcessorProviderClassName, symbols.getAddInitSvc(method))) .exprDotMethod(saiff, "setInsertInto", constant(insertInto)) .exprDotMethod(saiff, "setAddToFront", constant(addToFront)) .exprDotMethod(saiff, "setSelectAndDelete", constant(selectAndDelete)) .exprDotMethod(saiff, "setDistinct", constant(distinct)) .exprDotMethod(saiff, "setOptionalInsertIntoTable", optionalInsertIntoTable == null ? constantNull() : TableDeployTimeResolver.makeResolveTable(optionalInsertIntoTable, symbols.getAddInitSvc(method))); } }
public CodegenExpression codegen(EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { CodegenMethod method = codegenMethodScope.makeChild(Collection.class, EnumDistinctScalarForge.class, codegenClassScope).addParam(EnumForgeCodegenNames.PARAMS).getBlock() .ifCondition(relational(exprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "size"), LE, constant(1))) .blockReturn(EnumForgeCodegenNames.REF_ENUMCOLL) .ifCondition(instanceOf(ref("enumcoll"), Set.class)) .blockReturn(EnumForgeCodegenNames.REF_ENUMCOLL) .methodReturn(newInstance(LinkedHashSet.class, EnumForgeCodegenNames.REF_ENUMCOLL)); return localMethod(method, args.getExpressions()); } }