public EventType CreateMapType(IDictionary<string, object> map)
{
var metadata = new EventTypeMetadata(UuidGenerator.Generate(), null, EventTypeTypeClass.STREAM, EventTypeApplicationType.MAP, NameAccessModifier.INTERNAL, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned());
return new MapEventType(
metadata, map, null, null, null, null,
BEAN_EVENT_TYPE_FACTORY);
}
/// <summary>
/// Add an index specification element.
/// </summary>
/// <param name="indexProperties">list of property names to index</param>
/// <param name="coercionTypes">list of coercion types if required, or null if no coercion required</param>
/// <returns>number indicating position of index that was added</returns>
public string AddIndex(string[] indexProperties, Type[] coercionTypes)
{
string uuid = UuidGenerator.Generate();
_items.Put(new TableLookupIndexReqKey(uuid), new QueryPlanIndexItem(indexProperties, coercionTypes, null, null, false));
return(uuid);
}
private NamedWindowOnMergeActionIns SetupInsert(string namedWindowName, InternalEventRouter internalEventRouter, EventTypeSPI eventTypeNamedWindow, int selectClauseNumber, OnTriggerMergeActionInsert desc, EventType triggeringEventType, string triggeringStreamName, StatementContext statementContext)
{
// Compile insert-into INFO
string streamName = desc.OptionalStreamName ?? eventTypeNamedWindow.Name;
var insertIntoDesc = InsertIntoDesc.FromColumns(streamName, desc.Columns);
// rewrite any wildcards to use "stream.wildcard"
if (triggeringStreamName == null)
{
triggeringStreamName = UuidGenerator.Generate();
}
var selectNoWildcard = CompileSelectNoWildcard(triggeringStreamName, desc.SelectClauseCompiled);
// Set up event types for select-clause evaluation: The first type does not contain anything as its the named window row which is not present for insert
var dummyTypeNoProperties = new MapEventType(EventTypeMetadata.CreateAnonymous("merge_named_window_insert", ApplicationType.MAP), "merge_named_window_insert", 0, null, Collections.EmptyDataMap, null, null, null);
var eventTypes = new EventType[] { dummyTypeNoProperties, triggeringEventType };
var streamNames = new string[] { UuidGenerator.Generate(), triggeringStreamName };
var streamTypeService = new StreamTypeServiceImpl(eventTypes, streamNames, new bool[1], statementContext.EngineURI, false);
// Get select expr processor
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry(statementContext.StatementName, statementContext.StatementEventTypeRef);
var exprEvaluatorContext = new ExprEvaluatorContextStatement(statementContext, false);
var insertHelper = SelectExprProcessorFactory.GetProcessor(
statementContext.Container,
Collections.SingletonList(selectClauseNumber),
selectNoWildcard.ToArray(), false,
insertIntoDesc, null, null, streamTypeService,
statementContext.EventAdapterService,
statementContext.StatementResultService,
statementContext.ValueAddEventService,
selectExprEventTypeRegistry,
statementContext.EngineImportService,
exprEvaluatorContext,
statementContext.VariableService,
statementContext.ScriptingService,
statementContext.TableService,
statementContext.TimeProvider,
statementContext.EngineURI,
statementContext.StatementId,
statementContext.StatementName,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ConfigSnapshot, null,
statementContext.NamedWindowMgmtService, null, null,
statementContext.StatementExtensionServicesContext);
var filterEval = desc.OptionalWhereClause == null ? null : desc.OptionalWhereClause.ExprEvaluator;
var routerToUser = streamName.Equals(namedWindowName) ? null : internalEventRouter;
var audit = AuditEnum.INSERT.GetAudit(statementContext.Annotations) != null;
string insertIntoTableName = null;
if (statementContext.TableService.GetTableMetadata(insertIntoDesc.EventTypeName) != null)
{
insertIntoTableName = insertIntoDesc.EventTypeName;
}
return(new NamedWindowOnMergeActionIns(filterEval, insertHelper, routerToUser, insertIntoTableName, statementContext.TableService, statementContext.EpStatementHandle, statementContext.InternalEventEngineRouteDest, audit));
}
private static void SendAssertDotObjectEquals(
RegressionEnvironment env,
int intPrimitive,
bool expected)
{
env.SendEventBean(new SupportBean(UuidGenerator.Generate(), intPrimitive));
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), "c0".SplitCsv(), expected);
}
private void TryInvalidCompile(EPServiceProvider epService, string epl, string message)
{
try {
epService.EPAdministrator.CreateEPL(epl, UuidGenerator.Generate());
Assert.Fail();
} catch (EPStatementException ex) {
AssertException(message, ex.Message);
}
}
public static QueryPlanIndexForge MakeIndex(IList<QueryPlanIndexItemForge> indexesSet)
{
IDictionary<TableLookupIndexReqKey, QueryPlanIndexItemForge> items =
new LinkedHashMap<TableLookupIndexReqKey, QueryPlanIndexItemForge>();
foreach (var item in indexesSet) {
items.Put(new TableLookupIndexReqKey(UuidGenerator.Generate(), null), item);
}
return new QueryPlanIndexForge(items);
}
public static QueryPlanIndex MakeIndex(params QueryPlanIndexItem[] items)
{
IDictionary <TableLookupIndexReqKey, QueryPlanIndexItem> result = new LinkedHashMap <TableLookupIndexReqKey, QueryPlanIndexItem>();
foreach (QueryPlanIndexItem item in items)
{
result.Put(new TableLookupIndexReqKey(UuidGenerator.Generate()), item);
}
return(new QueryPlanIndex(result));
}
public static QueryPlanIndex MakeIndex(IList <QueryPlanIndexItem> indexesSet)
{
IDictionary <TableLookupIndexReqKey, QueryPlanIndexItem> items = new LinkedHashMap <TableLookupIndexReqKey, QueryPlanIndexItem>();
foreach (QueryPlanIndexItem item in indexesSet)
{
items.Put(new TableLookupIndexReqKey(UuidGenerator.Generate()), item);
}
return(new QueryPlanIndex(items));
}
public StmtNamedWindowIterateCallable(
string threadKey,
RegressionEnvironment env,
RegressionPath path,
int numRepeats)
{
this.env = env;
this.numRepeats = numRepeats;
this.threadKey = threadKey;
var stmtName = UuidGenerator.Generate();
env.CompileDeploy(
"@Name('" +
stmtName +
"') select TheString, sum(LongPrimitive) as sumLong from MyWindow group by TheString",
path);
statement = env.Statement(stmtName);
}
public string AddIndex(
string[] indexProperties,
Type[] coercionTypes,
EventType eventType)
{
var uuid = UuidGenerator.Generate();
Items.Put(
new TableLookupIndexReqKey(uuid, null),
new QueryPlanIndexItemForge(
indexProperties,
coercionTypes,
new string[0],
new Type[0],
false,
null,
eventType));
return uuid;
}
private void ScheduleNextCallback()
{
var nextScheduleCallback = new ProxyScheduleHandleCallback(delegate { ContinueSendingEvents(); });
var spi = (EPRuntimeSPI)_runtime;
var deploymentId = "CSV-adapter-" + UuidGenerator.Generate();
var metricsHandle = spi.ServicesContext.MetricReportingService.GetStatementHandle(-1, deploymentId, "AbstractCoordinatedAdapter");
var lockImpl = _container.RWLockManager().CreateLock("CSV");
var stmtHandle = new EPStatementHandle(
"AbstractCoordinatedAdapter", deploymentId, -1, null, 0, false, false,
spi.ServicesContext.MultiMatchHandlerFactory.Make(false, false), false, false, metricsHandle, null, null);
var agentInstanceHandle = new EPStatementAgentInstanceHandle(stmtHandle, -1, lockImpl);
var scheduleCSVHandle = new EPStatementHandleCallbackSchedule(agentInstanceHandle, nextScheduleCallback);
long nextScheduleSlot;
if (EventsToSend.IsEmpty())
{
if ((ExecutionPathDebugLog.IsDebugEnabled) && (Log.IsDebugEnabled))
{
Log.Debug(".scheduleNextCallback no events to send, scheduling callback in 100 ms");
}
nextScheduleSlot = 0L;
_schedulingService.Add(100, scheduleCSVHandle, nextScheduleSlot);
}
else
{
// Offset is not a function of the currentTime alone.
var first = EventsToSend.First();
long baseMsec = _currentTime - _startTime;
long afterMsec = first.SendTime - baseMsec;
nextScheduleSlot = first.ScheduleSlot;
if ((ExecutionPathDebugLog.IsDebugEnabled) && (Log.IsDebugEnabled))
{
Log.Debug(".scheduleNextCallback schedulingCallback in " + afterMsec + " milliseconds");
}
_schedulingService.Add(afterMsec, scheduleCSVHandle, nextScheduleSlot);
}
}
private static void RecursiveCompile(
EvalForgeNode evalNode,
ISet<string> eventTypeReferences,
bool isInsertInto,
MatchEventSpec tags,
Stack<EvalForgeNode> parentNodeStack,
ISet<string> allTagNamesOrdered,
int streamNum,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
parentNodeStack.Push(evalNode);
foreach (var child in evalNode.ChildNodes) {
RecursiveCompile(
child,
eventTypeReferences,
isInsertInto,
tags,
parentNodeStack,
allTagNamesOrdered,
streamNum,
statementRawInfo,
services);
}
parentNodeStack.Pop();
IDictionary<string, Pair<EventType, string>> newTaggedEventTypes = null;
IDictionary<string, Pair<EventType, string>> newArrayEventTypes = null;
if (evalNode is EvalFilterForgeNode) {
var filterNode = (EvalFilterForgeNode) evalNode;
var eventName = filterNode.RawFilterSpec.EventTypeName;
if (services.TableCompileTimeResolver.Resolve(eventName) != null) {
throw new ExprValidationException("Tables cannot be used in pattern filter atoms");
}
var resolvedEventType = ResolveTypeName(eventName, services.EventTypeCompileTimeResolver);
var finalEventType = resolvedEventType;
var optionalTag = filterNode.EventAsName;
var isPropertyEvaluation = false;
var isParentMatchUntil = IsParentMatchUntil(evalNode, parentNodeStack);
// obtain property event type, if final event type is properties
if (filterNode.RawFilterSpec.OptionalPropertyEvalSpec != null) {
var optionalPropertyEvaluator = PropertyEvaluatorForgeFactory.MakeEvaluator(
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
resolvedEventType,
filterNode.EventAsName,
statementRawInfo,
services);
finalEventType = optionalPropertyEvaluator.FragmentEventType;
isPropertyEvaluation = true;
}
// If a tag was supplied for the type, the tags must stay with this type, i.e. a=BeanA -> b=BeanA -> a=BeanB is a no
if (optionalTag != null) {
var pair = tags.TaggedEventTypes.Get(optionalTag);
EventType existingType = null;
if (pair != null) {
existingType = pair.First;
}
if (existingType == null) {
pair = tags.ArrayEventTypes.Get(optionalTag);
if (pair != null) {
throw new ExprValidationException(
"Tag '" +
optionalTag +
"' for event '" +
eventName +
"' used in the repeat-until operator cannot also appear in other filter expressions");
}
}
if (existingType != null && existingType != finalEventType) {
throw new ExprValidationException(
"Tag '" +
optionalTag +
"' for event '" +
eventName +
"' has already been declared for events of type " +
existingType.UnderlyingType.Name);
}
pair = new Pair<EventType, string>(finalEventType, eventName);
// add tagged type
if (isPropertyEvaluation || isParentMatchUntil) {
newArrayEventTypes = new LinkedHashMap<string, Pair<EventType, string>>();
newArrayEventTypes.Put(optionalTag, pair);
}
else {
newTaggedEventTypes = new LinkedHashMap<string, Pair<EventType, string>>();
newTaggedEventTypes.Put(optionalTag, pair);
}
}
// For this filter, filter types are all known tags at this time,
// and additionally stream 0 (self) is our event type.
// Stream type service allows resolution by property name event if that name appears in other tags.
// by defaulting to stream zero.
// Stream zero is always the current event type, all others follow the order of the map (stream 1 to N).
var selfStreamName = optionalTag;
if (selfStreamName == null) {
selfStreamName = "s_" + UuidGenerator.Generate();
}
var filterTypes = new LinkedHashMap<string, Pair<EventType, string>>();
var typePair = new Pair<EventType, string>(finalEventType, eventName);
filterTypes.Put(selfStreamName, typePair);
filterTypes.PutAll(tags.TaggedEventTypes);
// for the filter, specify all tags used
var filterTaggedEventTypes = new LinkedHashMap<string, Pair<EventType, string>>(tags.TaggedEventTypes);
filterTaggedEventTypes.Remove(optionalTag);
// handle array tags (match-until clause)
IDictionary<string, Pair<EventType, string>> arrayCompositeEventTypes = null;
if (tags.ArrayEventTypes != null && !tags.ArrayEventTypes.IsEmpty()) {
arrayCompositeEventTypes = new LinkedHashMap<string, Pair<EventType, string>>();
foreach (var entry in tags.ArrayEventTypes) {
var specificArrayType = new LinkedHashMap<string, Pair<EventType, string>>();
specificArrayType.Put(entry.Key, entry.Value);
var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousPatternNameWTag(
streamNum,
evalNode.FactoryNodeId,
entry.Key);
var mapProps = GetMapProperties(
Collections.GetEmptyMap<string, Pair<EventType, string>>(),
specificArrayType);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.PATTERNDERIVED,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var mapEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata,
mapProps,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(mapEventType);
var tag = entry.Key;
if (!filterTypes.ContainsKey(tag)) {
var pair = new Pair<EventType, string>(mapEventType, tag);
filterTypes.Put(tag, pair);
arrayCompositeEventTypes.Put(tag, pair);
}
}
}
StreamTypeService streamTypeService = new StreamTypeServiceImpl(filterTypes, true, false);
var exprNodes = filterNode.RawFilterSpec.FilterExpressions;
var spec = FilterSpecCompiler.MakeFilterSpec(
resolvedEventType,
eventName,
exprNodes,
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
filterTaggedEventTypes,
arrayCompositeEventTypes,
streamTypeService,
null,
statementRawInfo,
services);
filterNode.FilterSpec = spec;
}
else if (evalNode is EvalObserverForgeNode) {
var observerNode = (EvalObserverForgeNode) evalNode;
try {
var observerForge =
services.PatternResolutionService.Create(observerNode.PatternObserverSpec);
var streamTypeService = GetStreamTypeService(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
observerNode,
streamNum,
statementRawInfo,
services);
var validationContext = new ExprValidationContextBuilder(
streamTypeService,
statementRawInfo,
services).Build();
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNOBSERVER,
observerNode.PatternObserverSpec.ObjectParameters,
validationContext);
var convertor = new MatchedEventConvertorForge(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
allTagNamesOrdered);
observerNode.ObserverFactory = observerForge;
observerForge.SetObserverParameters(validated, convertor, validationContext);
}
catch (ObserverParameterException e) {
throw new ExprValidationException(
"Invalid parameter for pattern observer '" +
observerNode.ToPrecedenceFreeEPL() +
"': " +
e.Message,
e);
}
catch (PatternObjectException e) {
throw new ExprValidationException(
"Failed to resolve pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
}
else if (evalNode is EvalGuardForgeNode) {
var guardNode = (EvalGuardForgeNode) evalNode;
try {
var guardForge = services.PatternResolutionService.Create(guardNode.PatternGuardSpec);
var streamTypeService = GetStreamTypeService(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
guardNode,
streamNum,
statementRawInfo,
services);
var validationContext = new ExprValidationContextBuilder(
streamTypeService,
statementRawInfo,
services).Build();
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNGUARD,
guardNode.PatternGuardSpec.ObjectParameters,
validationContext);
var convertor = new MatchedEventConvertorForge(
tags.TaggedEventTypes,
tags.ArrayEventTypes,
allTagNamesOrdered);
guardNode.GuardForge = guardForge;
guardForge.SetGuardParameters(validated, convertor, services);
}
catch (GuardParameterException e) {
throw new ExprValidationException(
"Invalid parameter for pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
catch (PatternObjectException e) {
throw new ExprValidationException(
"Failed to resolve pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
}
else if (evalNode is EvalEveryDistinctForgeNode) {
var distinctNode = (EvalEveryDistinctForgeNode) evalNode;
var matchEventFromChildNodes = AnalyzeMatchEvent(distinctNode);
var streamTypeService = GetStreamTypeService(
matchEventFromChildNodes.TaggedEventTypes,
matchEventFromChildNodes.ArrayEventTypes,
distinctNode,
streamNum,
statementRawInfo,
services);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build();
IList<ExprNode> validated;
try {
validated = ValidateExpressions(
ExprNodeOrigin.PATTERNEVERYDISTINCT,
distinctNode.Expressions,
validationContext);
}
catch (ExprValidationPropertyException ex) {
throw new ExprValidationPropertyException(
ex.Message +
", every-distinct requires that all properties resolve from sub-expressions to the every-distinct",
ex.InnerException);
}
var convertor = new MatchedEventConvertorForge(
matchEventFromChildNodes.TaggedEventTypes,
matchEventFromChildNodes.ArrayEventTypes,
allTagNamesOrdered);
distinctNode.Convertor = convertor;
// Determine whether some expressions are constants or time period
IList<ExprNode> distinctExpressions = new List<ExprNode>();
TimePeriodComputeForge timePeriodComputeForge = null;
ExprNode expiryTimeExp = null;
var count = -1;
var last = validated.Count - 1;
foreach (var expr in validated) {
count++;
if (count == last && expr is ExprTimePeriod) {
expiryTimeExp = expr;
var timePeriodExpr = (ExprTimePeriod) expiryTimeExp;
timePeriodComputeForge = timePeriodExpr.TimePeriodComputeForge;
}
else if (expr.Forge.ForgeConstantType.IsCompileTimeConstant) {
if (count == last) {
var value = expr.Forge.ExprEvaluator.Evaluate(null, true, null);
if (!value.IsNumber()) {
throw new ExprValidationException(
"Invalid parameter for every-distinct, expected number of seconds constant (constant not considered for distinct)");
}
var secondsExpire = expr.Forge.ExprEvaluator.Evaluate(null, true, null);
var timeExpire = secondsExpire == null
? (long?) null
: (long?) services.ImportServiceCompileTime.TimeAbacus.DeltaForSecondsNumber(
secondsExpire);
if (timeExpire != null && timeExpire > 0) {
timePeriodComputeForge = new TimePeriodComputeConstGivenDeltaForge(timeExpire.Value);
expiryTimeExp = expr;
}
else {
Log.Warn(
"Invalid seconds-expire " +
timeExpire +
" for " +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr));
}
}
else {
Log.Warn(
"Every-distinct node utilizes an expression returning a constant value, please check expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr) +
"', not adding expression to distinct-value expression list");
}
}
else {
distinctExpressions.Add(expr);
}
}
if (distinctExpressions.IsEmpty()) {
throw new ExprValidationException(
"Every-distinct node requires one or more distinct-value expressions that each return non-constant result values");
}
distinctNode.SetDistinctExpressions(distinctExpressions, timePeriodComputeForge, expiryTimeExp);
}
else if (evalNode is EvalMatchUntilForgeNode) {
var matchUntilNode = (EvalMatchUntilForgeNode) evalNode;
// compile bounds expressions, if any
var untilMatchEventSpec = new MatchEventSpec(tags.TaggedEventTypes, tags.ArrayEventTypes);
var streamTypeService = GetStreamTypeService(
untilMatchEventSpec.TaggedEventTypes,
untilMatchEventSpec.ArrayEventTypes,
matchUntilNode,
streamNum,
statementRawInfo,
services);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build();
var lower = ValidateBounds(matchUntilNode.LowerBounds, validationContext);
matchUntilNode.LowerBounds = lower;
var upper = ValidateBounds(matchUntilNode.UpperBounds, validationContext);
matchUntilNode.UpperBounds = upper;
var single = ValidateBounds(matchUntilNode.SingleBound, validationContext);
matchUntilNode.SingleBound = single;
bool tightlyBound;
if (matchUntilNode.SingleBound != null) {
ValidateMatchUntil(matchUntilNode.SingleBound, matchUntilNode.SingleBound, false);
tightlyBound = true;
}
else {
var allowZeroLowerBounds = matchUntilNode.LowerBounds != null && matchUntilNode.UpperBounds != null;
tightlyBound = ValidateMatchUntil(
matchUntilNode.LowerBounds,
matchUntilNode.UpperBounds,
allowZeroLowerBounds);
}
if (matchUntilNode.SingleBound == null && !tightlyBound && matchUntilNode.ChildNodes.Count < 2) {
throw new ExprValidationException("Variable bounds repeat operator requires an until-expression");
}
var convertor = new MatchedEventConvertorForge(
untilMatchEventSpec.TaggedEventTypes,
untilMatchEventSpec.ArrayEventTypes,
allTagNamesOrdered);
matchUntilNode.Convertor = convertor;
// compile new tag lists
ISet<string> arrayTags = null;
var matchUntilAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes(matchUntilNode.ChildNodes[0]);
foreach (var filterNode in matchUntilAnalysisResult.FilterNodes) {
var optionalTag = filterNode.EventAsName;
if (optionalTag != null) {
if (arrayTags == null) {
arrayTags = new HashSet<string>();
}
arrayTags.Add(optionalTag);
}
}
if (arrayTags != null) {
foreach (var arrayTag in arrayTags) {
if (!tags.ArrayEventTypes.ContainsKey(arrayTag)) {
tags.ArrayEventTypes.Put(arrayTag, tags.TaggedEventTypes.Get(arrayTag));
tags.TaggedEventTypes.Remove(arrayTag);
}
}
}
matchUntilNode.TagsArrayedSet = GetIndexesForTags(allTagNamesOrdered, arrayTags);
}
else if (evalNode is EvalFollowedByForgeNode) {
var followedByNode = (EvalFollowedByForgeNode) evalNode;
StreamTypeService streamTypeService = new StreamTypeServiceImpl(false);
var validationContext =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services).Build();
if (followedByNode.OptionalMaxExpressions != null) {
IList<ExprNode> validated = new List<ExprNode>();
foreach (var maxExpr in followedByNode.OptionalMaxExpressions) {
if (maxExpr == null) {
validated.Add(null);
}
else {
var visitor = new ExprNodeSummaryVisitor();
maxExpr.Accept(visitor);
if (!visitor.IsPlain) {
var errorMessage = "Invalid maximum expression in followed-by, " +
visitor.Message +
" are not allowed within the expression";
Log.Error(errorMessage);
throw new ExprValidationException(errorMessage);
}
var validatedExpr = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.FOLLOWEDBYMAX,
maxExpr,
validationContext);
validated.Add(validatedExpr);
var returnType = validatedExpr.Forge.EvaluationType;
if (returnType == null || !returnType.IsNumeric()) {
var message =
"Invalid maximum expression in followed-by, the expression must return an integer value";
throw new ExprValidationException(message);
}
}
}
followedByNode.OptionalMaxExpressions = validated;
}
}
if (newTaggedEventTypes != null) {
tags.TaggedEventTypes.PutAll(newTaggedEventTypes);
}
if (newArrayEventTypes != null) {
tags.ArrayEventTypes.PutAll(newArrayEventTypes);
}
}
/// <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));
}
}
private CoursesCounter InitializeCounter()
{
return(CoursesCounter.Initialize(_uuidGenerator.Generate()));
}
protected override void InitExec(
string aliasName,
StatementSpecCompiled spec,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var selectNoWildcard = InfraOnMergeHelperForge.CompileSelectNoWildcard(
UuidGenerator.Generate(),
Arrays.AsList(spec.SelectClauseCompiled.SelectExprList));
StreamTypeService streamTypeService = new StreamTypeServiceImpl(true);
// assign names
var validationContext = new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
// determine whether column names are provided
// if the "values" keyword was used, allow sequential automatic name assignment
string[] assignedSequentialNames = null;
if (spec.Raw.InsertIntoDesc.ColumnNames.IsEmpty()) {
var insert = (FireAndForgetSpecInsert) spec.Raw.FireAndForgetSpec;
if (insert.IsUseValuesKeyword) {
assignedSequentialNames = processor.EventTypePublic.PropertyNames;
}
}
var count = -1;
foreach (var compiled in spec.SelectClauseCompiled.SelectExprList) {
count++;
if (compiled is SelectClauseExprCompiledSpec) {
var expr = (SelectClauseExprCompiledSpec) compiled;
var validatedExpression = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.SELECT,
expr.SelectExpression,
validationContext);
expr.SelectExpression = validatedExpression;
if (expr.AssignedName == null) {
if (expr.ProvidedName == null) {
if (assignedSequentialNames != null && count < assignedSequentialNames.Length) {
expr.AssignedName = assignedSequentialNames[count];
}
else {
expr.AssignedName =
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr.SelectExpression);
}
}
else {
expr.AssignedName = expr.ProvidedName;
}
}
}
}
EventType optionalInsertIntoEventType = processor.EventTypeRspInputEvents;
var args = new SelectProcessorArgs(
selectNoWildcard.ToArray(),
null,
false,
optionalInsertIntoEventType,
null,
streamTypeService,
statementRawInfo.OptionalContextDescriptor,
true,
spec.Annotations,
statementRawInfo,
services);
insertHelper = SelectExprProcessorFactory.GetProcessor(args, spec.Raw.InsertIntoDesc, false).Forge;
}
public override EPPreparedExecuteIUDSingleStreamExec GetExecutor(FilterSpecCompiled filter, string aliasName)
{
var selectNoWildcard = NamedWindowOnMergeHelper.CompileSelectNoWildcard(UuidGenerator.Generate(), StatementSpec.SelectClauseSpec.SelectExprList);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(StatementContext.EngineURI, true);
var exprEvaluatorContextStatement = new ExprEvaluatorContextStatement(StatementContext, true);
// assign names
var validationContext = new ExprValidationContext(
streamTypeService,
StatementContext.EngineImportService,
StatementContext.StatementExtensionServicesContext,
null, StatementContext.TimeProvider,
StatementContext.VariableService,
StatementContext.TableService,
exprEvaluatorContextStatement,
StatementContext.EventAdapterService,
StatementContext.StatementName,
StatementContext.StatementId,
StatementContext.Annotations,
StatementContext.ContextDescriptor,
StatementContext.ScriptingService,
false, false, true, false, null, false);
// determine whether column names are provided
// if the "values" keyword was used, allow sequential automatic name assignment
string[] assignedSequentialNames = null;
if (StatementSpec.InsertIntoDesc.ColumnNames.IsEmpty())
{
var insert = (FireAndForgetSpecInsert)StatementSpec.FireAndForgetSpec;
if (insert.IsUseValuesKeyword)
{
assignedSequentialNames = Processor.EventTypePublic.PropertyNames;
}
}
var count = -1;
foreach (var compiled in StatementSpec.SelectClauseSpec.SelectExprList)
{
count++;
if (compiled is SelectClauseExprCompiledSpec)
{
var expr = (SelectClauseExprCompiledSpec)compiled;
ExprNode validatedExpression = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.SELECT, expr.SelectExpression, validationContext);
expr.SelectExpression = validatedExpression;
if (expr.AssignedName == null)
{
if (expr.ProvidedName == null)
{
if (assignedSequentialNames != null && count < assignedSequentialNames.Length)
{
expr.AssignedName = assignedSequentialNames[count];
}
else
{
expr.AssignedName = ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(expr.SelectExpression);
}
}
else
{
expr.AssignedName = expr.ProvidedName;
}
}
}
}
EventType optionalInsertIntoEventType = Processor.EventTypeResultSetProcessor;
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry(StatementContext.StatementName, StatementContext.StatementEventTypeRef);
var insertHelper = SelectExprProcessorFactory.GetProcessor(
Collections.SingletonList(0),
selectNoWildcard.ToArray(), false,
StatementSpec.InsertIntoDesc, optionalInsertIntoEventType, null, streamTypeService,
StatementContext.EventAdapterService,
StatementContext.StatementResultService,
StatementContext.ValueAddEventService, selectExprEventTypeRegistry,
StatementContext.EngineImportService, exprEvaluatorContextStatement,
StatementContext.VariableService,
StatementContext.ScriptingService,
StatementContext.TableService,
StatementContext.TimeProvider,
StatementContext.EngineURI,
StatementContext.StatementId,
StatementContext.StatementName,
StatementContext.Annotations,
StatementContext.ContextDescriptor,
StatementContext.ConfigSnapshot, null,
StatementContext.NamedWindowMgmtService, null, null,
StatementContext.StatementExtensionServicesContext);
return(new EPPreparedExecuteIUDSingleStreamExecInsert(exprEvaluatorContextStatement, insertHelper, StatementSpec.TableNodes, Services));
}
public static PropertyEvaluatorForge MakeEvaluator(
PropertyEvalSpec spec,
EventType sourceEventType,
string optionalSourceStreamName,
StatementRawInfo rawInfo,
StatementCompileTimeServices services)
{
var length = spec.Atoms.Count;
var containedEventForges = new ContainedEventEvalForge[length];
var fragmentEventTypes = new FragmentEventType[length];
var currentEventType = sourceEventType;
var whereClauses = new ExprForge[length];
IList<EventType> streamEventTypes = new List<EventType>();
IList<string> streamNames = new List<string>();
IDictionary<string, int> streamNameAndNumber = new Dictionary<string, int>().WithNullKeySupport();
IList<string> expressionTexts = new List<string>();
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];
ContainedEventEvalForge 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 = ((EventTypeSPI) currentEventType).GetGetterSPI(propertyName);
if (getter != null) {
containedEventEval = new ContainedEventEvalGetterForge(getter);
expressionText = propertyName;
streamEventType = fragmentEventType.FragmentType;
}
}
}
// evaluate splitter expression
if (containedEventEval == null) {
ExprNodeUtilityValidate.ValidatePlainExpression(
ExprNodeOrigin.CONTAINEDEVENT,
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,
false,
false);
var validationContext = new ExprValidationContextBuilder(streamTypeService, rawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
var validatedExprNode = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.CONTAINEDEVENT,
atom.SplitterExpression,
validationContext);
// 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 '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) +
"'");
}
streamEventType = services.EventTypeCompileTimeResolver.GetTypeByName(atom.OptionalResultEventType);
if (streamEventType == null) {
throw new ExprValidationException(
"Event type by name '" + atom.OptionalResultEventType + "' could not be found");
}
var returnType = validatedExprNode.Forge.EvaluationType;
// 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 &&
!(streamEventType is JsonEventType) && // since json string-array should not become itself the property
TypeHelper.IsSubclassOrImplementsInterface(
returnType.GetElementType().GetBoxedType(),
streamEventType.GetPropertyType(streamEventType.PropertyNames[0]).GetBoxedType())) {
var writables = EventTypeUtility.GetWriteableProperties(streamEventType, false, false);
if (writables != null && !writables.IsEmpty()) {
try {
var manufacturer = EventTypeUtility.GetManufacturer(
streamEventType,
new[] {writables.First()},
services.ImportServiceCompileTime,
false,
services.EventTypeAvroHandler);
containedEventEval = new ContainedEventEvalArrayToEventForge(
validatedExprNode.Forge,
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 ContainedEventEvalEventBeanArrayForge(validatedExprNode.Forge);
}
else {
// check expression result type against eventtype expected underlying type
if (returnType.IsArray) {
if (!(streamEventType is JsonEventType)) {
if (!TypeHelper.IsSubclassOrImplementsInterface(
returnType.GetElementType(),
streamEventType.UnderlyingType)) {
throw new ExprValidationException(
"Event type '" +
streamEventType.Name +
"' underlying type " +
streamEventType.UnderlyingType.CleanName() +
" cannot be assigned a value of type " +
returnType.CleanName());
}
}
else {
if (returnType.GetElementType() != typeof(string)) {
throw new ExprValidationException(
"Event type '" +
streamEventType.Name +
"' requires string-type array and cannot be assigned from value of type " +
returnType.CleanName());
}
}
}
else if (GenericExtensions.IsGenericEnumerable(returnType) ||
TypeHelper.IsImplementsInterface<System.Collections.IEnumerable>(returnType)) {
// fine, assumed to return the right type
}
else {
throw new ExprValidationException(
"Return type of expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) +
"' is '" +
returnType.Name +
"', expected an Iterable or array result");
}
containedEventEval = new ContainedEventEvalExprNodeForge(
validatedExprNode.Forge,
streamEventType);
}
expressionText = ExprNodeUtilityPrint.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,
false,
false);
var validationContext = new ExprValidationContextBuilder(streamTypeService, rawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
var whereClause = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.CONTAINEDEVENT,
atom.OptionalWhereClause,
validationContext);
whereClauses[i] = whereClause.Forge;
}
// validate select clause
if (atom.OptionalSelectClause != null && !atom.OptionalSelectClause.SelectExprList.IsEmpty()) {
var whereTypes = streamEventTypes.ToArray();
var whereStreamNames = streamNames.ToArray();
var isIStreamOnly = new bool[streamNames.Count];
isIStreamOnly.Fill(true);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
whereTypes,
whereStreamNames,
isIStreamOnly,
false,
false);
var validationContext = new ExprValidationContextBuilder(streamTypeService, rawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
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);
var streamNumber = streamNameAndNumber.Get(rawStreamSpec.StreamName);
streamSpec.StreamNumber = streamNumber;
cumulativeSelectClause.Add(streamSpec);
}
else if (raw is SelectClauseExprRawSpec) {
var exprSpec = (SelectClauseExprRawSpec) raw;
var exprCompiled = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.CONTAINEDEVENT,
exprSpec.SelectExpression,
validationContext);
var resultName = exprSpec.OptionalAsName;
if (resultName == null) {
resultName = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprCompiled);
}
cumulativeSelectClause.Add(
new SelectClauseExprCompiledSpec(
exprCompiled,
resultName,
exprSpec.OptionalAsName,
exprSpec.IsEvents));
var isMinimal = ExprNodeUtilityValidate.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;
containedEventForges[i] = containedEventEval;
}
if (cumulativeSelectClause.IsEmpty()) {
if (length == 1) {
return new PropertyEvaluatorSimpleForge(
containedEventForges[0],
fragmentEventTypes[0],
whereClauses[0],
expressionTexts[0]);
}
return new PropertyEvaluatorNestedForge(
containedEventForges,
fragmentEventTypes,
whereClauses,
expressionTexts.ToArray());
}
{
var fragmentEventTypeIsIndexed = new bool[fragmentEventTypes.Length];
for (var i = 0; i < fragmentEventTypes.Length; i++) {
fragmentEventTypeIsIndexed[i] = fragmentEventTypes[i].IsIndexed;
}
var accumulative = new PropertyEvaluatorAccumulativeForge(
containedEventForges,
fragmentEventTypeIsIndexed,
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,
false,
false);
var cumulativeSelectArr = cumulativeSelectClause.ToArray();
var args = new SelectProcessorArgs(
cumulativeSelectArr,
null,
false,
null,
null,
streamTypeService,
null,
false,
rawInfo.Annotations,
rawInfo,
services);
var selectExprDesc = SelectExprProcessorFactory.GetProcessor(args, null, false);
return new PropertyEvaluatorSelectForge(selectExprDesc, accumulative);
}
}
private static void ValidateMergeDesc(
OnTriggerMergeDesc mergeDesc,
EventType namedWindowType,
string namedWindowName,
EventType triggerStreamType,
string triggerStreamName,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var exprNodeErrorMessage = "Aggregation functions may not be used within an merge-clause";
var dummyTypeNoPropertiesMeta = new EventTypeMetadata(
"merge_named_window_insert",
statementRawInfo.ModuleName,
EventTypeTypeClass.STREAM,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
EventType dummyTypeNoProperties = BaseNestableEventUtil.MakeMapTypeCompileTime(
dummyTypeNoPropertiesMeta,
Collections.GetEmptyMap<string, object>(),
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
StreamTypeService insertOnlyTypeSvc = new StreamTypeServiceImpl(
new[] {dummyTypeNoProperties, triggerStreamType},
new[] {UuidGenerator.Generate(), triggerStreamName},
new[] {true, true},
true,
false);
var twoStreamTypeSvc = new StreamTypeServiceImpl(
new[] {namedWindowType, triggerStreamType},
new[] {namedWindowName, triggerStreamName},
new[] {true, true},
true,
false);
foreach (var matchedItem in mergeDesc.Items) {
// we may provide an additional stream "initial" for the prior value, unless already defined
StreamTypeServiceImpl assignmentStreamTypeSvc;
if (namedWindowName.Equals(INITIAL_VALUE_STREAM_NAME) ||
triggerStreamName.Equals(INITIAL_VALUE_STREAM_NAME)) {
assignmentStreamTypeSvc = twoStreamTypeSvc;
}
else {
assignmentStreamTypeSvc = new StreamTypeServiceImpl(
new[] {namedWindowType, triggerStreamType, namedWindowType},
new[] {namedWindowName, triggerStreamName, INITIAL_VALUE_STREAM_NAME},
new[] {true, true, true},
false,
false);
assignmentStreamTypeSvc.IsStreamZeroUnambigous = true;
}
if (matchedItem.OptionalMatchCond != null) {
var matchValidStreams = matchedItem.IsMatchedUnmatched ? twoStreamTypeSvc : insertOnlyTypeSvc;
matchedItem.OptionalMatchCond = EPStatementStartMethodHelperValidate.ValidateExprNoAgg(
ExprNodeOrigin.MERGEMATCHCOND,
matchedItem.OptionalMatchCond,
matchValidStreams,
exprNodeErrorMessage,
true,
statementRawInfo,
services);
if (!matchedItem.IsMatchedUnmatched) {
EPStatementStartMethodHelperValidate.ValidateSubqueryExcludeOuterStream(
matchedItem.OptionalMatchCond);
}
}
foreach (var item in matchedItem.Actions) {
if (item is OnTriggerMergeActionDelete) {
var delete = (OnTriggerMergeActionDelete) item;
if (delete.OptionalWhereClause != null) {
delete.OptionalWhereClause = EPStatementStartMethodHelperValidate.ValidateExprNoAgg(
ExprNodeOrigin.MERGEMATCHWHERE,
delete.OptionalWhereClause,
twoStreamTypeSvc,
exprNodeErrorMessage,
true,
statementRawInfo,
services);
}
}
else if (item is OnTriggerMergeActionUpdate) {
var update = (OnTriggerMergeActionUpdate) item;
if (update.OptionalWhereClause != null) {
update.OptionalWhereClause = EPStatementStartMethodHelperValidate.ValidateExprNoAgg(
ExprNodeOrigin.MERGEMATCHWHERE,
update.OptionalWhereClause,
twoStreamTypeSvc,
exprNodeErrorMessage,
true,
statementRawInfo,
services);
}
foreach (var assignment in update.Assignments) {
assignment.Expression = EPStatementStartMethodHelperValidate.ValidateExprNoAgg(
ExprNodeOrigin.UPDATEASSIGN,
assignment.Expression,
assignmentStreamTypeSvc,
exprNodeErrorMessage,
true,
statementRawInfo,
services);
}
}
else if (item is OnTriggerMergeActionInsert) {
var insert = (OnTriggerMergeActionInsert) item;
var insertTypeSvc = GetInsertStreamService(
insert.OptionalStreamName,
namedWindowName,
insertOnlyTypeSvc,
twoStreamTypeSvc);
if (insert.OptionalWhereClause != null) {
insert.OptionalWhereClause = EPStatementStartMethodHelperValidate.ValidateExprNoAgg(
ExprNodeOrigin.MERGEMATCHWHERE,
insert.OptionalWhereClause,
insertTypeSvc,
exprNodeErrorMessage,
true,
statementRawInfo,
services);
}
var compiledSelect = ValidateInsertSelect(
insert.SelectClause,
insertTypeSvc,
insert.Columns,
statementRawInfo,
services);
insert.SelectClauseCompiled = compiledSelect;
}
else {
throw new ArgumentException("Unrecognized merge item '" + item.GetType().Name + "'");
}
}
}
if (mergeDesc.OptionalInsertNoMatch != null) {
var insertTypeSvc = GetInsertStreamService(
mergeDesc.OptionalInsertNoMatch.OptionalStreamName,
namedWindowName,
insertOnlyTypeSvc,
twoStreamTypeSvc);
var compiledSelect = ValidateInsertSelect(
mergeDesc.OptionalInsertNoMatch.SelectClause,
insertTypeSvc,
mergeDesc.OptionalInsertNoMatch.Columns,
statementRawInfo,
services);
mergeDesc.OptionalInsertNoMatch.SelectClauseCompiled = compiledSelect;
}
}
public static SupportBean GetResultTwoField(
string id,
int[] array)
{
return(new SupportBean(UuidGenerator.Generate(), 0));
}
public static String GenerateClassNameUUID() {
return UuidGenerator.Generate().Replace("-", "_");
}
private InfraOnMergeActionInsForge SetupInsert(
string infraName,
EventType infraType,
OnTriggerMergeActionInsert desc,
EventType triggeringEventType,
string triggeringStreamName,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services,
bool isTable)
{
// Compile insert-into info
var streamName = desc.OptionalStreamName != null ? desc.OptionalStreamName : infraName;
InsertIntoDesc insertIntoDesc = InsertIntoDesc.FromColumns(streamName, desc.Columns);
// rewrite any wildcards to use "stream.wildcard"
if (triggeringStreamName == null) {
triggeringStreamName = UuidGenerator.Generate();
}
var selectNoWildcard = CompileSelectNoWildcard(triggeringStreamName, desc.SelectClauseCompiled);
// Set up event types for select-clause evaluation: The first type does not contain anything as its the named-window or table row which is not present for insert
var eventTypeMetadata = new EventTypeMetadata(
"merge_infra_insert",
statementRawInfo.ModuleName,
EventTypeTypeClass.STREAM,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
EventType dummyTypeNoProperties = BaseNestableEventUtil.MakeMapTypeCompileTime(
eventTypeMetadata,
Collections.GetEmptyMap<string, object>(),
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
var eventTypes = new EventType[] {dummyTypeNoProperties, triggeringEventType};
var streamNames = new string[] {UuidGenerator.Generate(), triggeringStreamName};
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
eventTypes,
streamNames,
new bool[eventTypes.Length],
false,
false);
// Get select expr processor
var selectClause = selectNoWildcard.ToArray();
var args = new SelectProcessorArgs(
selectClause,
null,
false,
null,
null,
streamTypeService,
null,
false,
statementRawInfo.Annotations,
statementRawInfo,
services);
if (isTable && streamName.Equals(infraName)) {
args.OptionalInsertIntoEventType = infraType;
}
SelectExprProcessorForge insertHelperForge =
SelectExprProcessorFactory.GetProcessor(args, insertIntoDesc, false).Forge;
ExprNode filterEval = desc.OptionalWhereClause;
var route = !streamName.Equals(infraName);
bool audit = AuditEnum.INSERT.GetAudit(statementRawInfo.Annotations) != null;
TableMetaData insertIntoTable = services.TableCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName);
return new InfraOnMergeActionInsForge(filterEval, insertHelperForge, insertIntoTable, audit, route);
}
private static void RecursiveCompile(
EvalFactoryNode evalNode,
StatementContext context,
ExprEvaluatorContext evaluatorContext,
ICollection <string> eventTypeReferences,
bool isInsertInto,
MatchEventSpec tags,
Deque <int> subexpressionIdStack,
Stack <EvalFactoryNode> parentNodeStack,
ICollection <string> allTagNamesOrdered)
{
var counter = 0;
parentNodeStack.Push(evalNode);
foreach (var child in evalNode.ChildNodes)
{
subexpressionIdStack.AddLast(counter++);
RecursiveCompile(
child, context, evaluatorContext, eventTypeReferences, isInsertInto, tags, subexpressionIdStack,
parentNodeStack, allTagNamesOrdered);
subexpressionIdStack.RemoveLast();
}
parentNodeStack.Pop();
LinkedHashMap <string, Pair <EventType, string> > newTaggedEventTypes = null;
LinkedHashMap <string, Pair <EventType, string> > newArrayEventTypes = null;
if (evalNode is EvalFilterFactoryNode)
{
var filterNode = (EvalFilterFactoryNode)evalNode;
var eventName = filterNode.RawFilterSpec.EventTypeName;
if (context.TableService.GetTableMetadata(eventName) != null)
{
throw new ExprValidationException("Tables cannot be used in pattern filter atoms");
}
var resolvedEventType = FilterStreamSpecRaw.ResolveType(
context.EngineURI, eventName, context.EventAdapterService, context.PlugInTypeResolutionURIs);
var finalEventType = resolvedEventType;
var optionalTag = filterNode.EventAsName;
var isPropertyEvaluation = false;
var isParentMatchUntil = IsParentMatchUntil(evalNode, parentNodeStack);
// obtain property event type, if final event type is properties
if (filterNode.RawFilterSpec.OptionalPropertyEvalSpec != null)
{
var optionalPropertyEvaluator =
PropertyEvaluatorFactory.MakeEvaluator(
context.Container,
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
resolvedEventType,
filterNode.EventAsName,
context.EventAdapterService,
context.EngineImportService,
context.SchedulingService,
context.VariableService,
context.ScriptingService,
context.TableService,
context.EngineURI,
context.StatementId,
context.StatementName,
context.Annotations,
subexpressionIdStack,
context.ConfigSnapshot,
context.NamedWindowMgmtService,
context.StatementExtensionServicesContext);
finalEventType = optionalPropertyEvaluator.FragmentEventType;
isPropertyEvaluation = true;
}
if (finalEventType is EventTypeSPI)
{
eventTypeReferences.Add(((EventTypeSPI)finalEventType).Metadata.PrimaryName);
}
// If a tag was supplied for the type, the tags must stay with this type, i.e. a=BeanA -> b=BeanA -> a=BeanB is a no
if (optionalTag != null)
{
var pair = tags.TaggedEventTypes.Get(optionalTag);
EventType existingType = null;
if (pair != null)
{
existingType = pair.First;
}
if (existingType == null)
{
pair = tags.ArrayEventTypes.Get(optionalTag);
if (pair != null)
{
throw new ExprValidationException(
"Tag '" + optionalTag + "' for event '" + eventName +
"' used in the repeat-until operator cannot also appear in other filter expressions");
}
}
if ((existingType != null) && (existingType != finalEventType))
{
throw new ExprValidationException(
"Tag '" + optionalTag + "' for event '" + eventName +
"' has already been declared for events of type " + existingType.UnderlyingType.FullName);
}
pair = new Pair <EventType, string>(finalEventType, eventName);
// add tagged type
if (isPropertyEvaluation || isParentMatchUntil)
{
newArrayEventTypes = new LinkedHashMap <string, Pair <EventType, string> >();
newArrayEventTypes.Put(optionalTag, pair);
}
else
{
newTaggedEventTypes = new LinkedHashMap <string, Pair <EventType, string> >();
newTaggedEventTypes.Put(optionalTag, pair);
}
}
// For this filter, filter types are all known tags at this time,
// and additionally stream 0 (self) is our event type.
// Stream type service allows resolution by property name event if that name appears in other tags.
// by defaulting to stream zero.
// Stream zero is always the current event type, all others follow the order of the map (stream 1 to N).
var selfStreamName = optionalTag;
if (selfStreamName == null)
{
selfStreamName = "s_" + UuidGenerator.Generate();
}
var filterTypes = new LinkedHashMap <string, Pair <EventType, string> >();
var typePair = new Pair <EventType, string>(finalEventType, eventName);
filterTypes.Put(selfStreamName, typePair);
filterTypes.PutAll(tags.TaggedEventTypes);
// for the filter, specify all tags used
var filterTaggedEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(tags.TaggedEventTypes);
filterTaggedEventTypes.Remove(optionalTag);
// handle array tags (match-until clause)
LinkedHashMap <string, Pair <EventType, string> > arrayCompositeEventTypes = null;
if (tags.ArrayEventTypes != null && !tags.ArrayEventTypes.IsEmpty())
{
arrayCompositeEventTypes = new LinkedHashMap <string, Pair <EventType, string> >();
var patternSubexEventType = GetPatternSubexEventType(
context.StatementId, "pattern", subexpressionIdStack);
foreach (var entry in tags.ArrayEventTypes)
{
var specificArrayType = new LinkedHashMap <string, Pair <EventType, string> >();
specificArrayType.Put(entry.Key, entry.Value);
var arrayTagCompositeEventType =
context.EventAdapterService.CreateSemiAnonymousMapType(
patternSubexEventType, Collections.GetEmptyMap <string, Pair <EventType, string> >(),
specificArrayType, isInsertInto);
context.StatementSemiAnonymousTypeRegistry.Register(arrayTagCompositeEventType);
var tag = entry.Key;
if (!filterTypes.ContainsKey(tag))
{
var pair = new Pair <EventType, string>(arrayTagCompositeEventType, tag);
filterTypes.Put(tag, pair);
arrayCompositeEventTypes.Put(tag, pair);
}
}
}
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
filterTypes, context.EngineURI, true, false);
var exprNodes = filterNode.RawFilterSpec.FilterExpressions;
var spec = FilterSpecCompiler.MakeFilterSpec(
resolvedEventType, eventName, exprNodes,
filterNode.RawFilterSpec.OptionalPropertyEvalSpec,
filterTaggedEventTypes,
arrayCompositeEventTypes,
streamTypeService,
null, context, subexpressionIdStack);
filterNode.FilterSpec = spec;
}
else if (evalNode is EvalObserverFactoryNode)
{
var observerNode = (EvalObserverFactoryNode)evalNode;
try
{
var observerFactory = context.PatternResolutionService.Create(observerNode.PatternObserverSpec);
var streamTypeService = GetStreamTypeService(
context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes,
tags.ArrayEventTypes, subexpressionIdStack, "observer", context);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService, evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNOBSERVER, observerNode.PatternObserverSpec.ObjectParameters,
validationContext);
MatchedEventConvertor convertor = new MatchedEventConvertorImpl(
tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService);
observerNode.ObserverFactory = observerFactory;
observerFactory.SetObserverParameters(validated, convertor, validationContext);
}
catch (ObserverParameterException e)
{
throw new ExprValidationException(
"Invalid parameter for pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " +
e.Message, e);
}
catch (PatternObjectException e)
{
throw new ExprValidationException(
"Failed to resolve pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message,
e);
}
}
else if (evalNode is EvalGuardFactoryNode)
{
var guardNode = (EvalGuardFactoryNode)evalNode;
try
{
var guardFactory = context.PatternResolutionService.Create(guardNode.PatternGuardSpec);
var streamTypeService = GetStreamTypeService(
context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes,
tags.ArrayEventTypes, subexpressionIdStack, "guard", context);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService, evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
var validated = ValidateExpressions(
ExprNodeOrigin.PATTERNGUARD, guardNode.PatternGuardSpec.ObjectParameters, validationContext);
MatchedEventConvertor convertor = new MatchedEventConvertorImpl(
tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService);
guardNode.GuardFactory = guardFactory;
guardFactory.SetGuardParameters(validated, convertor);
}
catch (GuardParameterException e)
{
throw new ExprValidationException(
"Invalid parameter for pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e);
}
catch (PatternObjectException e)
{
throw new ExprValidationException(
"Failed to resolve pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e);
}
}
else if (evalNode is EvalEveryDistinctFactoryNode)
{
var distinctNode = (EvalEveryDistinctFactoryNode)evalNode;
var matchEventFromChildNodes = AnalyzeMatchEvent(distinctNode);
var streamTypeService = GetStreamTypeService(
context.EngineURI, context.StatementId, context.EventAdapterService,
matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes,
subexpressionIdStack, "every-distinct", context);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService, evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
IList <ExprNode> validated;
try
{
validated = ValidateExpressions(
ExprNodeOrigin.PATTERNEVERYDISTINCT, distinctNode.Expressions, validationContext);
}
catch (ExprValidationPropertyException ex)
{
throw new ExprValidationPropertyException(
ex.Message +
", every-distinct requires that all properties resolve from sub-expressions to the every-distinct",
ex.InnerException);
}
MatchedEventConvertor convertor =
new MatchedEventConvertorImpl(
matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes,
allTagNamesOrdered, context.EventAdapterService);
distinctNode.Convertor = convertor;
// Determine whether some expressions are constants or time period
IList <ExprNode> distinctExpressions = new List <ExprNode>();
ExprTimePeriodEvalDeltaConst timeDeltaComputation = null;
ExprNode expiryTimeExp = null;
var count = -1;
var last = validated.Count - 1;
foreach (var expr in validated)
{
count++;
if (count == last && expr is ExprTimePeriod)
{
expiryTimeExp = expr;
var timePeriodExpr = (ExprTimePeriod)expiryTimeExp;
timeDeltaComputation =
timePeriodExpr.ConstEvaluator(new ExprEvaluatorContextStatement(context, false));
}
else if (expr.IsConstantResult)
{
if (count == last)
{
var evaluateParams = new EvaluateParams(null, true, evaluatorContext);
var value = expr.ExprEvaluator.Evaluate(evaluateParams);
if (!(value.IsNumber()))
{
throw new ExprValidationException(
"Invalid parameter for every-distinct, expected number of seconds constant (constant not considered for distinct)");
}
var secondsExpire = expr.ExprEvaluator.Evaluate(evaluateParams);
long?timeExpire;
if (secondsExpire == null)
{
timeExpire = null;
}
else
{
timeExpire = context.TimeAbacus.DeltaForSecondsNumber(secondsExpire);
}
if (timeExpire != null && timeExpire > 0)
{
timeDeltaComputation = new ExprTimePeriodEvalDeltaConstGivenDelta(timeExpire.Value);
expiryTimeExp = expr;
}
else
{
Log.Warn("Invalid seconds-expire " + timeExpire + " for " + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(expr));
}
}
else
{
Log.Warn(
"Every-distinct node utilizes an expression returning a constant value, please check expression '{0}', not adding expression to distinct-value expression list",
expr.ToExpressionStringMinPrecedenceSafe());
}
}
else
{
distinctExpressions.Add(expr);
}
}
if (distinctExpressions.IsEmpty())
{
throw new ExprValidationException(
"Every-distinct node requires one or more distinct-value expressions that each return non-constant result values");
}
distinctNode.SetDistinctExpressions(distinctExpressions, timeDeltaComputation, expiryTimeExp);
}
else if (evalNode is EvalMatchUntilFactoryNode)
{
var matchUntilNode = (EvalMatchUntilFactoryNode)evalNode;
// compile bounds expressions, if any
var untilMatchEventSpec = new MatchEventSpec(tags.TaggedEventTypes, tags.ArrayEventTypes);
var streamTypeService = GetStreamTypeService(
context.EngineURI, context.StatementId, context.EventAdapterService,
untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, subexpressionIdStack,
"until", context);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService, evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
var lower = ValidateBounds(matchUntilNode.LowerBounds, validationContext);
matchUntilNode.LowerBounds = lower;
var upper = ValidateBounds(matchUntilNode.UpperBounds, validationContext);
matchUntilNode.UpperBounds = upper;
var single = ValidateBounds(matchUntilNode.SingleBound, validationContext);
matchUntilNode.SingleBound = single;
var convertor = new MatchedEventConvertorImpl(
untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, allTagNamesOrdered,
context.EventAdapterService);
matchUntilNode.Convertor = convertor;
// compile new tag lists
ISet <string> arrayTags = null;
var matchUntilAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes(matchUntilNode.ChildNodes[0]);
foreach (var filterNode in matchUntilAnalysisResult.FilterNodes)
{
var optionalTag = filterNode.EventAsName;
if (optionalTag != null)
{
if (arrayTags == null)
{
arrayTags = new HashSet <string>();
}
arrayTags.Add(optionalTag);
}
}
if (arrayTags != null)
{
foreach (var arrayTag in arrayTags)
{
if (!tags.ArrayEventTypes.ContainsKey(arrayTag))
{
tags.ArrayEventTypes.Put(arrayTag, tags.TaggedEventTypes.Get(arrayTag));
tags.TaggedEventTypes.Remove(arrayTag);
}
}
}
matchUntilNode.TagsArrayed = GetIndexesForTags(allTagNamesOrdered, arrayTags);
}
else if (evalNode is EvalFollowedByFactoryNode)
{
var followedByNode = (EvalFollowedByFactoryNode)evalNode;
StreamTypeService streamTypeService = new StreamTypeServiceImpl(context.EngineURI, false);
var validationContext = new ExprValidationContext(
context.Container,
streamTypeService,
context.EngineImportService,
context.StatementExtensionServicesContext, null,
context.SchedulingService,
context.VariableService,
context.TableService,
evaluatorContext,
context.EventAdapterService,
context.StatementName,
context.StatementId,
context.Annotations,
context.ContextDescriptor,
context.ScriptingService,
false, false, false, false, null, false);
if (followedByNode.OptionalMaxExpressions != null)
{
IList <ExprNode> validated = new List <ExprNode>();
foreach (var maxExpr in followedByNode.OptionalMaxExpressions)
{
if (maxExpr == null)
{
validated.Add(null);
}
else
{
var visitor = new ExprNodeSummaryVisitor();
maxExpr.Accept(visitor);
if (!visitor.IsPlain)
{
var errorMessage = "Invalid maximum expression in followed-by, " + visitor.GetMessage() +
" are not allowed within the expression";
Log.Error(errorMessage);
throw new ExprValidationException(errorMessage);
}
var validatedExpr = ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.FOLLOWEDBYMAX, maxExpr, validationContext);
validated.Add(validatedExpr);
if ((validatedExpr.ExprEvaluator.ReturnType == null) ||
(!validatedExpr.ExprEvaluator.ReturnType.IsNumeric()))
{
var message = "Invalid maximum expression in followed-by, the expression must return an integer value";
throw new ExprValidationException(message);
}
}
}
followedByNode.OptionalMaxExpressions = validated;
}
}
if (newTaggedEventTypes != null)
{
tags.TaggedEventTypes.PutAll(newTaggedEventTypes);
}
if (newArrayEventTypes != null)
{
tags.ArrayEventTypes.PutAll(newArrayEventTypes);
}
}
public static SupportBean GetResultIntArray(int[] array)
{
return(new SupportBean(UuidGenerator.Generate(), 0));
}
