Java StatementExtensionSvcContext类代码示例

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public void allocateVariableState(String variableName, int agentInstanceId, StatementExtensionSvcContext extensionServicesContext, boolean isRecoveringResilient) {
    VariableMetaData metaData = variables.get(variableName);
    if (metaData == null) {
        throw new IllegalArgumentException("Failed to find variable '" + variableName + "'");
    }

    // Check current state - see if the variable exists in the state handler
    Object initialState = metaData.getVariableStateFactory().getInitialState();
    if (optionalStateHandler != null) {
        Pair<Boolean, Object> priorValue = optionalStateHandler.getHasState(variableName, metaData.getVariableNumber(), agentInstanceId, metaData.getType(), metaData.getEventType(), extensionServicesContext, metaData.isConstant());
        if (isRecoveringResilient) {
            if (priorValue.getFirst()) {
                initialState = priorValue.getSecond();
            }
        } else {
            optionalStateHandler.setState(variableName, metaData.getVariableNumber(), agentInstanceId, initialState);
        }
    }

    // create new holder for versions
    long timestamp = timeProvider.getTime();
    VersionedValueList<Object> valuePerVersion = new VersionedValueList<Object>(variableName, currentVersionNumber, initialState, timestamp, millisecondLifetimeOldVersions, readWriteLock.readLock(), HIGH_WATERMARK_VERSIONS, false);
    Map<Integer, VariableReader> cps = variableVersionsPerCP.get(metaData.getVariableNumber());
    VariableReader reader = new VariableReader(metaData, versionThreadLocal, valuePerVersion);
    cps.put(agentInstanceId, reader);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public FilterSpecCompilerArgs(LinkedHashMap<String, Pair<EventType, String>> taggedEventTypes, LinkedHashMap<String, Pair<EventType, String>> arrayEventTypes, ExprEvaluatorContext exprEvaluatorContext, String statementName, int statementId, StreamTypeService streamTypeService, EngineImportService engineImportService, TimeProvider timeProvider, VariableService variableService, TableService tableService, EventAdapterService eventAdapterService, FilterBooleanExpressionFactory filterBooleanExpressionFactory, Annotation[] annotations, ContextDescriptor contextDescriptor, ConfigurationInformation configurationInformation, StatementExtensionSvcContext statementExtensionSvcContext) {
    this.taggedEventTypes = taggedEventTypes;
    this.arrayEventTypes = arrayEventTypes;
    this.exprEvaluatorContext = exprEvaluatorContext;
    this.statementName = statementName;
    this.statementId = statementId;
    this.streamTypeService = streamTypeService;
    this.engineImportService = engineImportService;
    this.timeProvider = timeProvider;
    this.variableService = variableService;
    this.tableService = tableService;
    this.eventAdapterService = eventAdapterService;
    this.filterBooleanExpressionFactory = filterBooleanExpressionFactory;
    this.annotations = annotations;
    this.contextDescriptor = contextDescriptor;
    this.configurationInformation = configurationInformation;
    this.statementExtensionSvcContext = statementExtensionSvcContext;
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public SortedAggregationStateFactoryFactory(EngineImportService engineImportService, StatementExtensionSvcContext statementExtensionSvcContext, ExprNode[] expressions, boolean[] sortDescending, boolean ever, int streamNum, ExprAggMultiFunctionSortedMinMaxByNode parent, ExprForge optionalFilter, boolean join) {
    this.engineImportService = engineImportService;
    this.statementExtensionSvcContext = statementExtensionSvcContext;
    this.expressions = expressions;
    this.sortDescending = sortDescending;
    this.ever = ever;
    this.streamNum = streamNum;
    this.parent = parent;
    this.optionalFilter = optionalFilter;
    this.join = join;
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public static FilterSpecCompiled buildNoStmtCtx(List<ExprNode> validatedFilterNodes,
                                                EventType eventType,
                                                String eventTypeName,
                                                PropertyEvalSpec optionalPropertyEvalSpec,
                                                LinkedHashMap<String, Pair<EventType, String>> taggedEventTypes,
                                                LinkedHashMap<String, Pair<EventType, String>> arrayEventTypes,
                                                StreamTypeService streamTypeService,
                                                String optionalStreamName,
                                                Collection<Integer> assignedTypeNumberStack,
                                                ExprEvaluatorContext exprEvaluatorContext,
                                                int statementId,
                                                String statementName,
                                                Annotation[] annotations,
                                                ContextDescriptor contextDescriptor,
                                                EngineImportService engineImportService,
                                                EventAdapterService eventAdapterService,
                                                FilterBooleanExpressionFactory filterBooleanExpressionFactory,
                                                TimeProvider timeProvider,
                                                VariableService variableService,
                                                TableService tableService,
                                                ConfigurationInformation configurationInformation,
                                                NamedWindowMgmtService namedWindowMgmtService,
                                                StatementExtensionSvcContext statementExtensionSvcContext) throws ExprValidationException {

    FilterSpecCompilerArgs args = new FilterSpecCompilerArgs(taggedEventTypes, arrayEventTypes, exprEvaluatorContext, statementName, statementId, streamTypeService, engineImportService, timeProvider, variableService, tableService, eventAdapterService, filterBooleanExpressionFactory, annotations, contextDescriptor, configurationInformation, statementExtensionSvcContext);
    List<FilterSpecParam>[] parameters = FilterSpecCompilerPlanner.planFilterParameters(validatedFilterNodes, args);

    PropertyEvaluator optionalPropertyEvaluator = null;
    if (optionalPropertyEvalSpec != null) {
        optionalPropertyEvaluator = PropertyEvaluatorFactory.makeEvaluator(optionalPropertyEvalSpec, eventType, optionalStreamName, eventAdapterService, engineImportService, timeProvider, variableService, tableService, streamTypeService.getEngineURIQualifier(), statementId, statementName, annotations, assignedTypeNumberStack, configurationInformation, namedWindowMgmtService, statementExtensionSvcContext);
    }

    FilterSpecCompiled spec = new FilterSpecCompiled(eventType, eventTypeName, parameters, optionalPropertyEvaluator);

    if (log.isDebugEnabled()) {
        log.debug(".makeFilterSpec spec=" + spec);
    }
    return spec;
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeCount(StatementExtensionSvcContext statementExtensionSvcContext, ExprCountNode exprCountNode, boolean ignoreNulls, Class countedValueType) {
    return new AggregationMethodFactoryCount(exprCountNode, ignoreNulls, countedValueType);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeSum(StatementExtensionSvcContext statementExtensionSvcContext, ExprSumNode exprSumNode, Class childType) {
    return new AggregationMethodFactorySum(exprSumNode, childType);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeAvedev(StatementExtensionSvcContext statementExtensionSvcContext, ExprAvedevNode exprAvedevNode, Class childType, ExprNode[] positionalParams) {
    return new AggregationMethodFactoryAvedev(exprAvedevNode, childType, positionalParams);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeAvg(StatementExtensionSvcContext statementExtensionSvcContext, ExprAvgNode exprAvgNode, Class childType, MathContext optionalMathContext) {
    return new AggregationMethodFactoryAvg(exprAvgNode, childType, optionalMathContext);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeCountEver(StatementExtensionSvcContext statementExtensionSvcContext, ExprCountEverNode exprCountEverNode, boolean ignoreNulls) {
    return new AggregationMethodFactoryCountEver(exprCountEverNode, ignoreNulls);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeFirstLastEver(StatementExtensionSvcContext statementExtensionSvcContext, ExprFirstLastEverNode exprFirstLastEverNode, Class type) {
    return new AggregationMethodFactoryFirstLastEver(exprFirstLastEverNode, type);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeLeaving(StatementExtensionSvcContext statementExtensionSvcContext, ExprLeavingAggNode exprLeavingAggNode) {
    return new AggregationMethodFactoryLeaving(exprLeavingAggNode);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeMedian(StatementExtensionSvcContext statementExtensionSvcContext, ExprMedianNode exprMedianNode, Class childType) {
    return new AggregationMethodFactoryMedian(exprMedianNode, childType);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeMinMax(StatementExtensionSvcContext statementExtensionSvcContext, ExprMinMaxAggrNode exprMinMaxAggrNode, Class type, boolean hasDataWindows) {
    return new AggregationMethodFactoryMinMax(exprMinMaxAggrNode, type, hasDataWindows);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makeNth(StatementExtensionSvcContext statementExtensionSvcContext, ExprNthAggNode exprNthAggNode, Class type, int size) {
    return new AggregationMethodFactoryNth(exprNthAggNode, type, size);
}
 

import com.espertech.esper.core.service.StatementExtensionSvcContext; //导入依赖的package包/类
public AggregationMethodFactory makePlugInMethod(StatementExtensionSvcContext statementExtensionSvcContext, ExprPlugInAggNode expr, AggregationFunctionFactory factory, Class childType) {
    return new AggregationMethodFactoryPlugIn(expr, factory, childType);
}