public AggregationStateFactory MakeSorted(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprAggMultiFunctionSortedMinMaxByNode expr,
AggregationStateSortedSpec spec)
{
return(new AggregationStateFactorySorted(expr, spec));
}
public AggregationMethodFactory MakeLinearUnbounded(StatementExtensionSvcContext statementExtensionSvcContext,
ExprAggMultiFunctionLinearAccessNode parent, EventType containedType, Type accessorResultType,
int streamNum, bool hasFilter)
{
return new AggregationMethodFactoryFirstLastUnbound(parent, containedType, accessorResultType, streamNum,
hasFilter);
}
public AggregationStateFactory MakeLinear(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprAggMultiFunctionLinearAccessNode expr,
int streamNum)
{
return(new AggregationStateFactoryLinear(expr, streamNum));
}
public AggregationStateFactoryCountMinSketch MakeCountMinSketch(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprAggCountMinSketchNode expr,
CountMinSketchSpec specification)
{
return(new AggregationStateFactoryCountMinSketch(expr, specification));
}
public AggregationMethodFactory MakeMedian(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprMedianNode exprMedianNode,
Type childType)
{
return(new AggregationMethodFactoryMedian(exprMedianNode, childType));
}
public AggregationMethodFactory MakeCountEver(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprCountEverNode exprCountEverNode,
bool ignoreNulls)
{
return(new AggregationMethodFactoryCountEver(exprCountEverNode, ignoreNulls));
}
public AggregationMethodFactory MakeLastEver(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprLastEverNode exprLastEverNode,
Type type)
{
return(new AggregationMethodFactoryLastEver(exprLastEverNode, type));
}
public ExprValidationContext(StreamTypeService streamTypeService, EngineImportService engineImportService, StatementExtensionSvcContext statementExtensionSvcContext, ViewResourceDelegateUnverified viewResourceDelegate, TimeProvider timeProvider, VariableService variableService, TableService tableService, ExprEvaluatorContext exprEvaluatorContext, EventAdapterService eventAdapterService, string statementName, int statementId, Attribute[] annotations, ContextDescriptor contextDescriptor, ScriptingService scriptingService, bool disablePropertyExpressionEventCollCache, bool allowRollupFunctions, bool allowBindingConsumption, bool isUnidirectionalJoin, string intoTableName, bool isFilterExpression)
{
StreamTypeService = streamTypeService;
EngineImportService = engineImportService;
StatementExtensionSvcContext = statementExtensionSvcContext;
ViewResourceDelegate = viewResourceDelegate;
TimeProvider = timeProvider;
VariableService = variableService;
TableService = tableService;
ExprEvaluatorContext = exprEvaluatorContext;
EventAdapterService = eventAdapterService;
StatementName = statementName;
StatementId = statementId;
Annotations = annotations;
ContextDescriptor = contextDescriptor;
ScriptingService = scriptingService;
IsDisablePropertyExpressionEventCollCache = disablePropertyExpressionEventCollCache;
IsAllowRollupFunctions = allowRollupFunctions;
IsAllowBindingConsumption = allowBindingConsumption;
IsResettingAggregations = isUnidirectionalJoin;
IntoTableName = intoTableName;
IsFilterExpression = isFilterExpression;
IsExpressionAudit = AuditEnum.EXPRESSION.GetAudit(annotations) != null;
IsExpressionNestedAudit = AuditEnum.EXPRESSION_NESTED.GetAudit(annotations) != null;
}
public void AllocateVariableState(String variableName, int agentInstanceId, StatementExtensionSvcContext extensionServicesContext)
{
var metaData = _variables.Get(variableName);
if (metaData == null)
{
throw new ArgumentException("Failed to find variable '" + variableName + "'");
}
// Check current state - see if the variable exists in the state handler
var initialState = metaData.VariableStateFactory.InitialState;
if (_optionalStateHandler != null)
{
var priorValue = _optionalStateHandler.GetHasState(
variableName,
metaData.VariableNumber, agentInstanceId,
metaData.VariableType,
metaData.EventType, extensionServicesContext);
if (priorValue.First)
{
initialState = priorValue.Second;
}
}
// create new holder for versions
var timestamp = _timeProvider.Time;
var valuePerVersion = new VersionedValueList <Object>(variableName, _currentVersionNumber, initialState, timestamp, _millisecondLifetimeOldVersions, _readWriteLock.ReadLock, HIGH_WATERMARK_VERSIONS, false);
var cps = _variableVersionsPerCP[metaData.VariableNumber];
var reader = new VariableReader(metaData, _versionThreadLocal, valuePerVersion);
cps.Put(agentInstanceId, reader);
}
// settable for view-sharing
/// <summary>
/// Constructor.
/// </summary>
/// <param name="stmtEngineServices">is the engine services for the statement</param>
/// <param name="schedulingService">implementation for schedule registration</param>
/// <param name="scheduleBucket">is for ordering scheduled callbacks within the view statements</param>
/// <param name="epStatementHandle">is the statements-own handle for use in registering callbacks with services</param>
/// <param name="viewResultionService">is a service for resolving view namespace and name to a view factory</param>
/// <param name="patternResolutionService">is the service that resolves pattern objects for the statement</param>
/// <param name="statementExtensionSvcContext">provide extension points for custom statement resources</param>
/// <param name="statementStopService">for registering a callback invoked when a statement is stopped</param>
/// <param name="methodResolutionService">is a service for resolving static methods and aggregation functions</param>
/// <param name="patternContextFactory">is the pattern-level services and context information factory</param>
/// <param name="filterService">is the filtering service</param>
/// <param name="statementResultService">handles awareness of listeners/subscriptions for a statement customizing output produced</param>
/// <param name="internalEventEngineRouteDest">routing destination</param>
/// <param name="annotations">The annotations.</param>
/// <param name="statementAgentInstanceRegistry">The statement agent instance registry.</param>
/// <param name="defaultAgentInstanceLock">The default agent instance lock.</param>
/// <param name="contextDescriptor">The context descriptor.</param>
/// <param name="patternSubexpressionPoolSvc">The pattern subexpression pool SVC.</param>
/// <param name="matchRecognizeStatePoolStmtSvc">The match recognize state pool statement SVC.</param>
/// <param name="statelessSelect">if set to <c>true</c> [stateless select].</param>
/// <param name="contextControllerFactoryService">The context controller factory service.</param>
/// <param name="defaultAgentInstanceScriptContext">The default agent instance script context.</param>
/// <param name="aggregationServiceFactoryService">The aggregation service factory service.</param>
/// <param name="scriptingService">The scripting service.</param>
/// <param name="writesToTables">if set to <c>true</c> [writes to tables].</param>
/// <param name="statementUserObject">The statement user object.</param>
/// <param name="statementSemiAnonymousTypeRegistry">The statement semi anonymous type registry.</param>
/// <param name="priority">The priority.</param>
public StatementContext(
StatementContextEngineServices stmtEngineServices,
SchedulingService schedulingService,
ScheduleBucket scheduleBucket,
EPStatementHandle epStatementHandle,
ViewResolutionService viewResultionService,
PatternObjectResolutionService patternResolutionService,
StatementExtensionSvcContext statementExtensionSvcContext,
StatementStopService statementStopService,
MethodResolutionService methodResolutionService,
PatternContextFactory patternContextFactory,
FilterService filterService,
StatementResultService statementResultService,
InternalEventRouteDest internalEventEngineRouteDest,
Attribute[] annotations,
StatementAIResourceRegistry statementAgentInstanceRegistry,
IReaderWriterLock defaultAgentInstanceLock,
ContextDescriptor contextDescriptor,
PatternSubexpressionPoolStmtSvc patternSubexpressionPoolSvc,
MatchRecognizeStatePoolStmtSvc matchRecognizeStatePoolStmtSvc,
bool statelessSelect,
ContextControllerFactoryService contextControllerFactoryService,
AgentInstanceScriptContext defaultAgentInstanceScriptContext,
AggregationServiceFactoryService aggregationServiceFactoryService,
ScriptingService scriptingService,
bool writesToTables,
object statementUserObject,
StatementSemiAnonymousTypeRegistry statementSemiAnonymousTypeRegistry,
int priority)
{
_stmtEngineServices = stmtEngineServices;
SchedulingService = schedulingService;
ScheduleBucket = scheduleBucket;
EpStatementHandle = epStatementHandle;
ViewResolutionService = viewResultionService;
PatternResolutionService = patternResolutionService;
StatementExtensionServicesContext = statementExtensionSvcContext;
StatementStopService = statementStopService;
MethodResolutionService = methodResolutionService;
PatternContextFactory = patternContextFactory;
FilterService = filterService;
_statementResultService = statementResultService;
InternalEventEngineRouteDest = internalEventEngineRouteDest;
ScheduleAdjustmentService = stmtEngineServices.ConfigSnapshot.EngineDefaults.ExecutionConfig.IsAllowIsolatedService ? new ScheduleAdjustmentService() : null;
Annotations = annotations;
StatementAgentInstanceRegistry = statementAgentInstanceRegistry;
DefaultAgentInstanceLock = defaultAgentInstanceLock;
ContextDescriptor = contextDescriptor;
PatternSubexpressionPoolSvc = patternSubexpressionPoolSvc;
MatchRecognizeStatePoolStmtSvc = matchRecognizeStatePoolStmtSvc;
IsStatelessSelect = statelessSelect;
ContextControllerFactoryService = contextControllerFactoryService;
DefaultAgentInstanceScriptContext = defaultAgentInstanceScriptContext;
AggregationServiceFactoryService = aggregationServiceFactoryService;
ScriptingService = scriptingService;
IsWritesToTables = writesToTables;
StatementUserObject = statementUserObject;
StatementSemiAnonymousTypeRegistry = statementSemiAnonymousTypeRegistry;
Priority = priority;
}
public AggregationMethodFactory MakeSum(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprSumNode exprSumNode,
Type childType)
{
return(new AggregationMethodFactorySum(exprSumNode, childType));
}
public ExprPlugInAggMultiFunctionNodeFactory(ExprPlugInAggMultiFunctionNode parent, PlugInAggregationMultiFunctionHandler handlerPlugin, AggregationFactoryFactory aggregationFactoryFactory, StatementExtensionSvcContext statementExtensionSvcContext)
{
_handlerPlugin = handlerPlugin;
_parent = parent;
_aggregationFactoryFactory = aggregationFactoryFactory;
_statementExtensionSvcContext = statementExtensionSvcContext;
}
public AggregationMethodFactory MakePlugInMethod(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprPlugInAggNode expr,
AggregationFunctionFactory factory,
Type childType)
{
return(new AggregationMethodFactoryPlugIn(expr, factory, childType));
}
public AggregationMethodFactory MakeAvg(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprAvgNode exprAvgNode,
Type childType,
MathContext optionalMathContext)
{
return(new AggregationMethodFactoryAvg(exprAvgNode, childType, optionalMathContext));
}
public AggregationMethodFactory MakeMinMax(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprMinMaxAggrNode exprMinMaxAggrNode,
Type type,
bool hasDataWindows)
{
return(new AggregationMethodFactoryMinMax(exprMinMaxAggrNode, type, hasDataWindows));
}
public AggregationMethodFactory MakeAvedev(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprAvedevNode exprAvedevNode,
Type childType,
ExprNode[] positionalParams)
{
return(new AggregationMethodFactoryAvedev(exprAvedevNode, childType, positionalParams));
}
public AggregationMethodFactory MakeNth(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprNthAggNode exprNthAggNode,
Type type,
int size)
{
return(new AggregationMethodFactoryNth(exprNthAggNode, type, size));
}
public AggregationMethodFactory MakeCount(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprCountNode exprCountNode,
bool ignoreNulls,
Type countedValueType)
{
return(new AggregationMethodFactoryCount(exprCountNode, ignoreNulls, countedValueType));
}
public AggregationMethodFactory MakeRate(
StatementExtensionSvcContext statementExtensionSvcContext,
ExprRateAggNode exprRateAggNode,
bool isEver,
long intervalTime,
TimeProvider timeProvider,
TimeAbacus timeAbacus)
{
return(new AggregationMethodFactoryRate(exprRateAggNode, isEver, intervalTime, timeProvider, timeAbacus));
}
public SortedAggregationStateFactoryFactory(EngineImportService engineImportService,
StatementExtensionSvcContext statementExtensionSvcContext, ExprEvaluator[] evaluators,
bool[] sortDescending, bool ever, int streamNum, ExprAggMultiFunctionSortedMinMaxByNode parent,
ExprEvaluator optionalFilter)
{
_engineImportService = engineImportService;
_statementExtensionSvcContext = statementExtensionSvcContext;
_evaluators = evaluators;
_sortDescending = sortDescending;
_ever = ever;
_streamNum = streamNum;
_parent = parent;
_optionalFilter = optionalFilter;
}
public FilterSpecCompilerArgs(
IContainer container,
IDictionary<string, Pair<EventType, string>> taggedEventTypes,
IDictionary<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,
ScriptingService scriptingService,
Attribute[] annotations,
ContextDescriptor contextDescriptor,
ConfigurationInformation configurationInformation,
StatementExtensionSvcContext statementExtensionSvcContext)
{
Container = container;
TaggedEventTypes = taggedEventTypes;
ArrayEventTypes = arrayEventTypes;
ExprEvaluatorContext = exprEvaluatorContext;
StatementName = statementName;
StatementId = statementId;
StreamTypeService = streamTypeService;
EngineImportService = engineImportService;
TimeProvider = timeProvider;
VariableService = variableService;
TableService = tableService;
EventAdapterService = eventAdapterService;
FilterBooleanExpressionFactory = filterBooleanExpressionFactory;
ScriptingService = scriptingService;
Annotations = annotations;
ContextDescriptor = contextDescriptor;
ConfigurationInformation = configurationInformation;
StatementExtensionSvcContext = statementExtensionSvcContext;
}
public AggregationMethodFactory MakeStddev(StatementExtensionSvcContext statementExtensionSvcContext,
ExprStddevNode exprStddevNode, Type childType)
{
return new AggregationMethodFactoryStddev(exprStddevNode, childType);
}
/// <summary>
/// Returns the processor to use for a given select-clause.
/// </summary>
/// <param name="assignedTypeNumberStack">The assigned type number stack.</param>
/// <param name="selectionList">the list of select clause elements/items, which are expected to have been validated</param>
/// <param name="isUsingWildcard">true if the wildcard (*) occurs in the select clause</param>
/// <param name="insertIntoDesc">contains column names for the optional insert-into clause (if supplied)</param>
/// <param name="optionalInsertIntoEventType">Type of the optional insert into event.</param>
/// <param name="forClauseSpec">For clause spec.</param>
/// <param name="typeService">serves stream type information</param>
/// <param name="eventAdapterService">for generating wrapper instances for events</param>
/// <param name="statementResultService">handles listeners/subscriptions awareness to reduce output result generation</param>
/// <param name="valueAddEventService">service that handles update events and variant events</param>
/// <param name="selectExprEventTypeRegistry">registry for event type to statements</param>
/// <param name="engineImportService"></param>
/// <param name="exprEvaluatorContext">context for expression evalauation</param>
/// <param name="variableService">The variable service.</param>
/// <param name="scriptingService">The scripting service.</param>
/// <param name="tableService">The table service.</param>
/// <param name="timeProvider">The time provider.</param>
/// <param name="engineURI">The engine URI.</param>
/// <param name="statementId">The statement identifier.</param>
/// <param name="statementName">Name of the statement.</param>
/// <param name="annotations">The annotations.</param>
/// <param name="contextDescriptor">The context descriptor.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="selectExprProcessorCallback">The select expr processor callback.</param>
/// <param name="namedWindowMgmtService">The named window service.</param>
/// <param name="intoTableClause">The into table clause.</param>
/// <param name="groupByRollupInfo"></param>
/// <param name="statementExtensionSvcContext"></param>
/// <returns>
/// select-clause expression processor
/// </returns>
/// <exception cref="ExprValidationException">Expected any of the + Arrays.ToString(ForClauseKeyword.Values()).ToLowerCase() + for-clause keywords after reserved keyword 'for'
/// or
/// The for-clause with the + ForClauseKeyword.GROUPED_DELIVERY.Name + keyword requires one or more grouping expressions
/// or
/// The for-clause with the + ForClauseKeyword.DISCRETE_DELIVERY.Name + keyword does not allow grouping expressions
/// or
/// The for-clause with delivery keywords may only occur once in a statement
/// or
/// Expected any of the + Arrays.ToString(ForClauseKeyword.Values()).ToLowerCase() + for-clause keywords after reserved keyword 'for'</exception>
/// <throws>ExprValidationException to indicate the select expression cannot be validated</throws>
public static SelectExprProcessor GetProcessor(
ICollection <int> assignedTypeNumberStack,
SelectClauseElementCompiled[] selectionList,
bool isUsingWildcard,
InsertIntoDesc insertIntoDesc,
EventType optionalInsertIntoEventType,
ForClauseSpec forClauseSpec,
StreamTypeService typeService,
EventAdapterService eventAdapterService,
StatementResultService statementResultService,
ValueAddEventService valueAddEventService,
SelectExprEventTypeRegistry selectExprEventTypeRegistry,
EngineImportService engineImportService,
ExprEvaluatorContext exprEvaluatorContext,
VariableService variableService,
ScriptingService scriptingService,
TableService tableService,
TimeProvider timeProvider,
string engineURI,
int statementId,
string statementName,
Attribute[] annotations,
ContextDescriptor contextDescriptor,
ConfigurationInformation configuration,
SelectExprProcessorDeliveryCallback selectExprProcessorCallback,
NamedWindowMgmtService namedWindowMgmtService,
IntoTableSpec intoTableClause,
GroupByRollupInfo groupByRollupInfo,
StatementExtensionSvcContext statementExtensionSvcContext)
{
if (selectExprProcessorCallback != null)
{
var bindProcessor = new BindProcessor(selectionList, typeService.EventTypes, typeService.StreamNames, tableService);
IDictionary <string, object> properties = new LinkedHashMap <string, object>();
for (var i = 0; i < bindProcessor.ColumnNamesAssigned.Length; i++)
{
properties.Put(bindProcessor.ColumnNamesAssigned[i], bindProcessor.ExpressionTypes[i]);
}
var eventType = eventAdapterService.CreateAnonymousObjectArrayType("Output_" + statementName, properties);
return(new SelectExprProcessorWDeliveryCallback(eventType, bindProcessor, selectExprProcessorCallback));
}
var synthetic = GetProcessorInternal(
assignedTypeNumberStack, selectionList, isUsingWildcard, insertIntoDesc, optionalInsertIntoEventType,
typeService, eventAdapterService, valueAddEventService, selectExprEventTypeRegistry,
engineImportService, statementId, statementName, annotations, configuration, namedWindowMgmtService, tableService,
groupByRollupInfo);
// Handle table as an optional service
if (statementResultService != null)
{
// Handle for-clause delivery contract checking
ExprNode[] groupedDeliveryExpr = null;
var forDelivery = false;
if (forClauseSpec != null)
{
foreach (var item in forClauseSpec.Clauses)
{
if (item.Keyword == null)
{
throw new ExprValidationException("Expected any of the " + EnumHelper.GetValues <ForClauseKeyword>().Render().ToLower() + " for-clause keywords after reserved keyword 'for'");
}
try
{
ForClauseKeyword keyword = EnumHelper.Parse <ForClauseKeyword>(item.Keyword);
if ((keyword == ForClauseKeyword.GROUPED_DELIVERY) && (item.Expressions.IsEmpty()))
{
throw new ExprValidationException(
"The for-clause with the " + ForClauseKeyword.GROUPED_DELIVERY.GetName() +
" keyword requires one or more grouping expressions");
}
if ((keyword == ForClauseKeyword.DISCRETE_DELIVERY) && (!item.Expressions.IsEmpty()))
{
throw new ExprValidationException(
"The for-clause with the " + ForClauseKeyword.DISCRETE_DELIVERY.GetName() +
" keyword does not allow grouping expressions");
}
if (forDelivery)
{
throw new ExprValidationException(
"The for-clause with delivery keywords may only occur once in a statement");
}
}
catch (ExprValidationException)
{
throw;
}
catch (EPException)
{
throw;
}
catch (Exception ex)
{
throw new ExprValidationException("Expected any of the " + EnumHelper.GetValues <ForClauseKeyword>().Render().ToLower() + " for-clause keywords after reserved keyword 'for'", ex);
}
StreamTypeService type = new StreamTypeServiceImpl(synthetic.ResultEventType, null, false, engineURI);
groupedDeliveryExpr = new ExprNode[item.Expressions.Count];
var validationContext = new ExprValidationContext(type, engineImportService, statementExtensionSvcContext, null, timeProvider, variableService, tableService, exprEvaluatorContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService, false, false, true, false, intoTableClause == null ? null : intoTableClause.Name, false); // no context descriptor available
for (var i = 0; i < item.Expressions.Count; i++)
{
groupedDeliveryExpr[i] = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.FORCLAUSE, item.Expressions[i], validationContext);
}
forDelivery = true;
}
}
var bindProcessor = new BindProcessor(selectionList, typeService.EventTypes, typeService.StreamNames, tableService);
statementResultService.SetSelectClause(bindProcessor.ExpressionTypes, bindProcessor.ColumnNamesAssigned, forDelivery, ExprNodeUtility.GetEvaluators(groupedDeliveryExpr), exprEvaluatorContext);
return(new SelectExprResultProcessor(statementResultService, synthetic, bindProcessor));
}
return(synthetic);
}
public AggregationStateFactory MakeLinear(StatementExtensionSvcContext statementExtensionSvcContext,
ExprAggMultiFunctionLinearAccessNode expr, int streamNum, ExprEvaluator optionalFilter)
{
return new AggregationStateFactoryLinear(expr, streamNum, optionalFilter);
}
/// <summary>
/// Makes the property evaluator.
/// </summary>
/// <param name="spec">is the property specification</param>
/// <param name="sourceEventType">the event type</param>
/// <param name="optionalSourceStreamName">the source stream name</param>
/// <param name="eventAdapterService">for event instances</param>
/// <param name="engineImportService">The engine import service.</param>
/// <param name="timeProvider">provides time</param>
/// <param name="variableService">for resolving variables</param>
/// <param name="scriptingService">The scripting service.</param>
/// <param name="tableService">The table service.</param>
/// <param name="engineURI">engine URI</param>
/// <param name="statementId">The statement identifier.</param>
/// <param name="statementName">Name of the statement.</param>
/// <param name="annotations">The annotations.</param>
/// <param name="assignedTypeNumberStack">The assigned type number stack.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="namedWindowMgmtService">The named window service.</param>
/// <param name="statementExtensionSvcContext">The statement extension SVC context.</param>
/// <returns>
/// propert evaluator
/// </returns>
/// <exception cref="ExprValidationException">Missing @type(name) declaration providing the event type name of the return type for expression ' +
/// ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + '
/// or
/// Event type by name ' + atom.OptionalResultEventType + ' could not be found
/// or
/// Event type ' + streamEventType.Name + ' underlying type + streamEventType.UnderlyingType.Name +
/// cannot be assigned a value of type + returnType.GetTypeNameFullyQualPretty()
/// or
/// Return type of expression ' + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + ' is ' + returnType.Name + ', expected an Iterable or array result
/// or
/// Property rename ' + rawStreamSpec.MaskTypeName + ' not found in path
/// or
/// Expression in a property-selection may not utilize + isMinimal</exception>
/// <exception cref="IllegalStateException">Unknown select clause item: + raw</exception>
/// <throws>ExprValidationException if any expressions could not be verified</throws>
public static PropertyEvaluator MakeEvaluator(
PropertyEvalSpec spec,
EventType sourceEventType,
string optionalSourceStreamName,
EventAdapterService eventAdapterService,
EngineImportService engineImportService,
TimeProvider timeProvider,
VariableService variableService,
ScriptingService scriptingService,
TableService tableService,
string engineURI,
int statementId,
string statementName,
Attribute[] annotations,
ICollection <int> assignedTypeNumberStack,
ConfigurationInformation configuration,
NamedWindowMgmtService namedWindowMgmtService,
StatementExtensionSvcContext statementExtensionSvcContext)
{
var length = spec.Atoms.Count;
var containedEventEvals = new ContainedEventEval[length];
var fragmentEventTypes = new FragmentEventType[length];
var currentEventType = sourceEventType;
var whereClauses = new ExprEvaluator[length];
var streamEventTypes = new List <EventType>();
var streamNames = new List <string>();
var streamNameAndNumber = new Dictionary <string, int>().WithNullSupport();
var expressionTexts = new List <string>();
var validateContext = new ExprEvaluatorContextTimeOnly(timeProvider);
streamEventTypes.Add(sourceEventType);
streamNames.Add(optionalSourceStreamName);
streamNameAndNumber.Put(optionalSourceStreamName, 0);
expressionTexts.Add(sourceEventType.Name);
IList <SelectClauseElementCompiled> cumulativeSelectClause = new List <SelectClauseElementCompiled>();
for (var i = 0; i < length; i++)
{
var atom = spec.Atoms[i];
ContainedEventEval containedEventEval = null;
string expressionText = null;
EventType streamEventType = null;
FragmentEventType fragmentEventType = null;
// Resolve directly as fragment event type if possible
if (atom.SplitterExpression is ExprIdentNode)
{
var propertyName = ((ExprIdentNode)atom.SplitterExpression).FullUnresolvedName;
fragmentEventType = currentEventType.GetFragmentType(propertyName);
if (fragmentEventType != null)
{
var getter = currentEventType.GetGetter(propertyName);
if (getter != null)
{
containedEventEval = new ContainedEventEvalGetter(getter);
expressionText = propertyName;
streamEventType = fragmentEventType.FragmentType;
}
}
}
// evaluate splitter expression
if (containedEventEval == null)
{
ExprNodeUtility.ValidatePlainExpression(
ExprNodeOrigin.CONTAINEDEVENT,
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression),
atom.SplitterExpression);
var availableTypes = streamEventTypes.ToArray();
var availableStreamNames = streamNames.ToArray();
var isIStreamOnly = new bool[streamNames.Count];
isIStreamOnly.Fill(true);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
availableTypes, availableStreamNames, isIStreamOnly, engineURI, false);
var validationContext = new ExprValidationContext(
streamTypeService, engineImportService, statementExtensionSvcContext, null, timeProvider, variableService, tableService,
validateContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService,
false, false, true, false, null, false);
var validatedExprNode = ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.CONTAINEDEVENT, atom.SplitterExpression, validationContext);
var evaluator = validatedExprNode.ExprEvaluator;
// determine result type
if (atom.OptionalResultEventType == null)
{
throw new ExprValidationException(
"Missing @type(name) declaration providing the event type name of the return type for expression '" +
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + "'");
}
streamEventType = eventAdapterService.GetEventTypeByName(atom.OptionalResultEventType);
if (streamEventType == null)
{
throw new ExprValidationException(
"Event type by name '" + atom.OptionalResultEventType + "' could not be found");
}
var returnType = evaluator.ReturnType;
// when the expression returns an array, allow array values to become the column of the single-column event type
if (returnType.IsArray &&
streamEventType.PropertyNames.Length == 1 &&
TypeHelper.IsSubclassOrImplementsInterface(
TypeHelper.GetBoxedType(returnType.GetElementType()),
TypeHelper.GetBoxedType(streamEventType.GetPropertyType(streamEventType.PropertyNames[0]))))
{
var writables = eventAdapterService.GetWriteableProperties(streamEventType, false);
if (!writables.IsEmpty())
{
try
{
EventBeanManufacturer manufacturer = EventAdapterServiceHelper.GetManufacturer(
eventAdapterService, streamEventType,
new WriteablePropertyDescriptor[] { writables.First() },
engineImportService, false,
eventAdapterService.EventAdapterAvroHandler);
containedEventEval = new ContainedEventEvalArrayToEvent(evaluator, manufacturer);
}
catch (EventBeanManufactureException e)
{
throw new ExprValidationException(
"Event type '" + streamEventType.Name + "' cannot be populated: " + e.Message, e);
}
}
else
{
throw new ExprValidationException("Event type '" + streamEventType.Name + "' cannot be written to");
}
}
else if (returnType.IsArray() && returnType.GetElementType() == typeof(EventBean))
{
containedEventEval = new ContainedEventEvalEventBeanArray(evaluator);
}
else
{
EventBeanFactory eventBeanFactory = EventAdapterServiceHelper.GetFactoryForType(
streamEventType, eventAdapterService);
// check expression result type against eventtype expected underlying type
if (returnType.IsArray())
{
if (!TypeHelper.IsSubclassOrImplementsInterface(returnType.GetElementType(), streamEventType.UnderlyingType))
{
throw new ExprValidationException(
"Event type '" + streamEventType.Name + "' underlying type " +
streamEventType.UnderlyingType.FullName +
" cannot be assigned a value of type " + TypeHelper.GetTypeNameFullyQualPretty(returnType));
}
}
else if (GenericExtensions.IsGenericEnumerable(returnType) || returnType.IsImplementsInterface <IEnumerable>())
{
// fine, assumed to return the right type
}
else
{
throw new ExprValidationException(
"Return type of expression '" +
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + "' is '" +
returnType.FullName + "', expected an Iterable or array result");
}
containedEventEval = new ContainedEventEvalExprNode(evaluator, eventBeanFactory);
}
expressionText = ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validatedExprNode);
fragmentEventType = new FragmentEventType(streamEventType, true, false);
}
// validate where clause, if any
streamEventTypes.Add(streamEventType);
streamNames.Add(atom.OptionalAsName);
streamNameAndNumber.Put(atom.OptionalAsName, i + 1);
expressionTexts.Add(expressionText);
if (atom.OptionalWhereClause != null)
{
var whereTypes = streamEventTypes.ToArray();
var whereStreamNames = streamNames.ToArray();
var isIStreamOnly = new bool[streamNames.Count];
isIStreamOnly.Fill(true);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
whereTypes, whereStreamNames, isIStreamOnly, engineURI, false);
var validationContext = new ExprValidationContext(
streamTypeService, engineImportService, statementExtensionSvcContext, null, timeProvider, variableService, tableService,
validateContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService,
false, false, true, false, null, false);
whereClauses[i] =
ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.CONTAINEDEVENT, atom.OptionalWhereClause, validationContext).ExprEvaluator;
}
// validate select clause
if (atom.OptionalSelectClause != null)
{
var whereTypes = streamEventTypes.ToArray();
var whereStreamNames = streamNames.ToArray();
var isIStreamOnly = new bool[streamNames.Count];
isIStreamOnly.Fill(true);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
whereTypes, whereStreamNames, isIStreamOnly, engineURI, false);
var validationContext = new ExprValidationContext(
streamTypeService, engineImportService, statementExtensionSvcContext, null, timeProvider, variableService, tableService,
validateContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService,
false, false, true, false, null, false);
foreach (var raw in atom.OptionalSelectClause.SelectExprList)
{
if (raw is SelectClauseStreamRawSpec)
{
var rawStreamSpec = (SelectClauseStreamRawSpec)raw;
if (!streamNames.Contains(rawStreamSpec.StreamName))
{
throw new ExprValidationException(
"Property rename '" + rawStreamSpec.StreamName + "' not found in path");
}
var streamSpec = new SelectClauseStreamCompiledSpec(
rawStreamSpec.StreamName, rawStreamSpec.OptionalAsName);
int streamNumber = streamNameAndNumber.Get(rawStreamSpec.StreamName);
streamSpec.StreamNumber = streamNumber;
cumulativeSelectClause.Add(streamSpec);
}
else if (raw is SelectClauseExprRawSpec)
{
var exprSpec = (SelectClauseExprRawSpec)raw;
var exprCompiled = ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.CONTAINEDEVENT, exprSpec.SelectExpression, validationContext);
var resultName = exprSpec.OptionalAsName;
if (resultName == null)
{
resultName = ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(exprCompiled);
}
cumulativeSelectClause.Add(
new SelectClauseExprCompiledSpec(
exprCompiled, resultName, exprSpec.OptionalAsName, exprSpec.IsEvents));
var isMinimal = ExprNodeUtility.IsMinimalExpression(exprCompiled);
if (isMinimal != null)
{
throw new ExprValidationException(
"Expression in a property-selection may not utilize " + isMinimal);
}
}
else if (raw is SelectClauseElementWildcard)
{
// wildcards are stream selects: we assign a stream name (any) and add a stream wildcard select
var streamNameAtom = atom.OptionalAsName;
if (streamNameAtom == null)
{
streamNameAtom = UuidGenerator.Generate();
}
var streamSpec = new SelectClauseStreamCompiledSpec(streamNameAtom, atom.OptionalAsName);
var streamNumber = i + 1;
streamSpec.StreamNumber = streamNumber;
cumulativeSelectClause.Add(streamSpec);
}
else
{
throw new IllegalStateException("Unknown select clause item:" + raw);
}
}
}
currentEventType = fragmentEventType.FragmentType;
fragmentEventTypes[i] = fragmentEventType;
containedEventEvals[i] = containedEventEval;
}
if (cumulativeSelectClause.IsEmpty())
{
if (length == 1)
{
return(new PropertyEvaluatorSimple(
containedEventEvals[0], fragmentEventTypes[0], whereClauses[0], expressionTexts[0]));
}
else
{
return(new PropertyEvaluatorNested(containedEventEvals, fragmentEventTypes, whereClauses, expressionTexts));
}
}
else
{
var accumulative = new PropertyEvaluatorAccumulative(
containedEventEvals, fragmentEventTypes, whereClauses, expressionTexts);
var whereTypes = streamEventTypes.ToArray();
var whereStreamNames = streamNames.ToArray();
var isIStreamOnly = new bool[streamNames.Count];
isIStreamOnly.Fill(true);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
whereTypes, whereStreamNames, isIStreamOnly, engineURI, false);
var cumulativeSelectArr = cumulativeSelectClause.ToArray();
var selectExpr = SelectExprProcessorFactory.GetProcessor(
assignedTypeNumberStack, cumulativeSelectArr, false, null, null, null, streamTypeService,
eventAdapterService, null, null, null, engineImportService, validateContext, variableService,
scriptingService,
tableService, timeProvider, engineURI, statementId, statementName, annotations, null, configuration, null,
namedWindowMgmtService, null, null, statementExtensionSvcContext);
return(new PropertyEvaluatorSelect(selectExpr, accumulative));
}
}
public static FilterSpecCompiled BuildNoStmtCtx(
IContainer container,
IList <ExprNode> validatedFilterNodes,
EventType eventType,
string eventTypeName,
PropertyEvalSpec optionalPropertyEvalSpec,
IDictionary <string, Pair <EventType, string> > taggedEventTypes,
IDictionary <string, Pair <EventType, string> > arrayEventTypes,
StreamTypeService streamTypeService,
string optionalStreamName,
ICollection <int> assignedTypeNumberStack,
ExprEvaluatorContext exprEvaluatorContext,
int statementId,
string statementName,
Attribute[] annotations,
ContextDescriptor contextDescriptor,
EngineImportService engineImportService,
EventAdapterService eventAdapterService,
FilterBooleanExpressionFactory filterBooleanExpressionFactory,
TimeProvider timeProvider,
VariableService variableService,
ScriptingService scriptingService,
TableService tableService,
ConfigurationInformation configurationInformation,
NamedWindowMgmtService namedWindowMgmtService,
StatementExtensionSvcContext statementExtensionSvcContext)
{
var args = new FilterSpecCompilerArgs(
container,
taggedEventTypes,
arrayEventTypes,
exprEvaluatorContext,
statementName,
statementId,
streamTypeService,
engineImportService,
timeProvider,
variableService,
tableService,
eventAdapterService,
filterBooleanExpressionFactory,
scriptingService,
annotations,
contextDescriptor,
configurationInformation,
statementExtensionSvcContext);
var parameters = FilterSpecCompilerPlanner.PlanFilterParameters(validatedFilterNodes, args);
PropertyEvaluator optionalPropertyEvaluator = null;
if (optionalPropertyEvalSpec != null)
{
optionalPropertyEvaluator = PropertyEvaluatorFactory.MakeEvaluator(
container,
optionalPropertyEvalSpec,
eventType,
optionalStreamName,
eventAdapterService,
engineImportService,
timeProvider,
variableService,
scriptingService,
tableService,
streamTypeService.EngineURIQualifier,
statementId,
statementName,
annotations,
assignedTypeNumberStack,
configurationInformation,
namedWindowMgmtService,
statementExtensionSvcContext);
}
var spec = new FilterSpecCompiled(eventType, eventTypeName, parameters, optionalPropertyEvaluator);
if (Log.IsDebugEnabled)
{
Log.Debug(".makeFilterSpec spec=" + spec);
}
return(spec);
}
public AggregationStateFactory MakeMinMaxEver(StatementExtensionSvcContext statementExtensionSvcContext,
ExprAggMultiFunctionSortedMinMaxByNode expr, AggregationStateMinMaxByEverSpec spec)
{
return new AggregationStateFactoryMinMaxByEver(expr, spec);
}
public AggregationMethodFactory MakeLeaving(StatementExtensionSvcContext statementExtensionSvcContext, ExprLeavingAggNode exprLeavingAggNode)
{
return(new AggregationMethodFactoryLeaving(exprLeavingAggNode));
}
public AggregationStateFactory MakePlugInAccess(StatementExtensionSvcContext statementExtensionSvcContext, ExprPlugInAggMultiFunctionNodeFactory factory)
{
return(new AggregationStateFactoryPlugin(factory));
}
