private ContextControllerFactoryForge Make(
ContextControllerFactoryEnv factoryContext,
ContextSpec detail)
{
ContextControllerFactoryForge forge;
if (detail is ContextSpecInitiatedTerminated) {
forge = new ContextControllerInitTermFactoryForge(
factoryContext,
(ContextSpecInitiatedTerminated) detail);
}
else if (detail is ContextSpecKeyed) {
forge = new ContextControllerKeyedFactoryForge(factoryContext, (ContextSpecKeyed) detail);
}
else if (detail is ContextSpecCategory) {
forge = new ContextControllerCategoryFactoryForge(factoryContext, (ContextSpecCategory) detail);
}
else if (detail is ContextSpecHash) {
forge = new ContextControllerHashFactoryForge(factoryContext, (ContextSpecHash) detail);
}
else {
throw new UnsupportedOperationException(
"Context detail " + detail + " is not yet supported in a nested context");
}
return forge;
}
private ContextControllerFactoryForge[] GetForges(
string contextName,
ContextSpec contextDetail)
{
if (!(contextDetail is ContextNested)) {
var factoryEnv = new ContextControllerFactoryEnv(
contextName,
contextName,
1,
1);
return new[] {Make(factoryEnv, contextDetail)};
}
var nested = (ContextNested) contextDetail;
var forges = new ContextControllerFactoryForge[nested.Contexts.Count];
var nestingLevel = 1;
foreach (var desc in nested.Contexts) {
var factoryEnv = new ContextControllerFactoryEnv(
contextName,
desc.ContextName,
nestingLevel,
nested.Contexts.Count);
forges[nestingLevel - 1] = Make(factoryEnv, desc.ContextDetail);
nestingLevel++;
}
return forges;
}
public CreateContextDesc(
string contextName,
ContextSpec contextDetail)
{
ContextName = contextName;
ContextDetail = contextDetail;
}
private IList<StmtClassForgeableFactory> ValidateContextDetail(
ContextSpec contextSpec,
int nestingLevel,
CreateContextValidationEnv validationEnv)
{
ISet<string> eventTypesReferenced = new HashSet<string>();
IList<StmtClassForgeableFactory> additionalForgeables = new List<StmtClassForgeableFactory>();
if (contextSpec is ContextSpecKeyed) {
var segmented = (ContextSpecKeyed) contextSpec;
IDictionary<string, EventType> asNames = new Dictionary<string, EventType>();
var partitionHasNameAssignment = false;
Type[] getterTypes = null;
foreach (var partition in segmented.Items) {
Pair<FilterSpecCompiled, IList<StmtClassForgeableFactory>> pair = CompilePartitionedFilterSpec(
partition.FilterSpecRaw, eventTypesReferenced, validationEnv);
FilterSpecCompiled filterSpecCompiled = pair.First;
additionalForgeables.AddAll(pair.Second);
partition.FilterSpecCompiled = filterSpecCompiled;
var getters = new EventPropertyGetterSPI[partition.PropertyNames.Count];
var serdes = new DataInputOutputSerdeForge[partition.PropertyNames.Count];
var eventType = (EventTypeSPI) filterSpecCompiled.FilterForEventType;
getterTypes = new Type[partition.PropertyNames.Count];
for (var i = 0; i < partition.PropertyNames.Count; i++) {
var propertyName = partition.PropertyNames[i];
var getter = eventType.GetGetterSPI(propertyName);
if (getter == null) {
throw new ExprValidationException(
"For context '" + validationEnv.ContextName + "' property name '" + propertyName + "' not found on type " + eventType.Name);
}
getters[i] = getter;
getterTypes[i] = eventType.GetPropertyType(propertyName);
serdes[i] = validationEnv.Services.SerdeResolver.SerdeForFilter(
getterTypes[i], validationEnv.StatementRawInfo);
}
partition.Getters = getters;
partition.LookupableSerdes = serdes;
if (partition.AliasName != null) {
partitionHasNameAssignment = true;
ValidateAsName(asNames, partition.AliasName, filterSpecCompiled.FilterForEventType);
}
}
// plan multi-key, make sure we use the same multikey for all items
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(
getterTypes, false, @base.StatementRawInfo, validationEnv.Services.SerdeResolver);
additionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables);
foreach (ContextSpecKeyedItem partition in segmented.Items) {
partition.KeyMultiKey = multiKeyPlan.ClassRef;
}
segmented.MultiKeyClassRef = multiKeyPlan.ClassRef;
if (segmented.OptionalInit != null) {
asNames.Clear();
foreach (var initCondition in segmented.OptionalInit) {
ContextDetailMatchPair pair = ValidateRewriteContextCondition(
true,
nestingLevel,
initCondition,
eventTypesReferenced,
new MatchEventSpec(),
new EmptySet<string>(),
validationEnv);
additionalForgeables.AddAll(pair.AdditionalForgeables);
var filterForType = initCondition.FilterSpecCompiled.FilterForEventType;
var found = false;
foreach (var partition in segmented.Items) {
if (partition.FilterSpecCompiled.FilterForEventType == filterForType) {
found = true;
break;
}
}
if (!found) {
throw new ExprValidationException(
"Segmented context '" +
validationEnv.ContextName +
"' requires that all of the event types that are listed in the initialized-by also appear in the partition-by, type '" +
filterForType.Name +
"' is not one of the types listed in partition-by");
}
if (initCondition.OptionalFilterAsName != null) {
if (partitionHasNameAssignment) {
throw new ExprValidationException(
"Segmented context '" +
validationEnv.ContextName +
"' requires that either partition-by or initialized-by assign stream names, but not both");
}
ValidateAsName(asNames, initCondition.OptionalFilterAsName, filterForType);
}
}
}
if (segmented.OptionalTermination != null) {
var matchEventSpec = new MatchEventSpec();
var allTags = new LinkedHashSet<string>();
foreach (var partition in segmented.Items) {
if (partition.AliasName != null) {
allTags.Add(partition.AliasName);
var eventType = partition.FilterSpecCompiled.FilterForEventType;
matchEventSpec.TaggedEventTypes[partition.AliasName] = new Pair<EventType,string>(
eventType, partition.FilterSpecRaw.EventTypeName);
var serdeForgeables = SerdeEventTypeUtility.Plan(
eventType,
validationEnv.StatementRawInfo,
validationEnv.Services.SerdeEventTypeRegistry,
validationEnv.Services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
if (segmented.OptionalInit != null) {
foreach (var initCondition in segmented.OptionalInit) {
if (initCondition.OptionalFilterAsName != null) {
allTags.Add(initCondition.OptionalFilterAsName);
matchEventSpec.TaggedEventTypes.Put(
initCondition.OptionalFilterAsName,
new Pair<EventType, string>(
initCondition.FilterSpecCompiled.FilterForEventType,
initCondition.FilterSpecRaw.EventTypeName));
}
}
}
var endCondition = ValidateRewriteContextCondition(
false,
nestingLevel,
segmented.OptionalTermination,
eventTypesReferenced,
matchEventSpec,
allTags,
validationEnv);
additionalForgeables.AddAll(endCondition.AdditionalForgeables);
segmented.OptionalTermination = endCondition.Condition;
}
}
else if (contextSpec is ContextSpecCategory) {
// compile filter
var category = (ContextSpecCategory) contextSpec;
ValidateNotTable(category.FilterSpecRaw.EventTypeName, validationEnv.Services);
var raw = new FilterStreamSpecRaw(
category.FilterSpecRaw,
ViewSpec.EMPTY_VIEWSPEC_ARRAY,
null,
StreamSpecOptions.DEFAULT);
var compiledDesc = StreamSpecCompiler.CompileFilter(
raw,
false,
false,
true,
false,
null,
validationEnv.StatementRawInfo,
validationEnv.Services);
var result = (FilterStreamSpecCompiled) compiledDesc.StreamSpecCompiled;
additionalForgeables.AddAll(compiledDesc.AdditionalForgeables);
category.FilterSpecCompiled = result.FilterSpecCompiled;
validationEnv.FilterSpecCompileds.Add(result.FilterSpecCompiled);
// compile expressions
foreach (var item in category.Items) {
ValidateNotTable(category.FilterSpecRaw.EventTypeName, validationEnv.Services);
var filterSpecRaw = new FilterSpecRaw(
category.FilterSpecRaw.EventTypeName,
Collections.SingletonList(item.Expression),
null);
var rawExpr = new FilterStreamSpecRaw(
filterSpecRaw,
ViewSpec.EMPTY_VIEWSPEC_ARRAY,
null,
StreamSpecOptions.DEFAULT);
var compiledDescItems = StreamSpecCompiler.CompileFilter(
rawExpr,
false,
false,
true,
false,
null,
validationEnv.StatementRawInfo,
validationEnv.Services);
var compiled = (FilterStreamSpecCompiled) compiledDescItems.StreamSpecCompiled;
additionalForgeables.AddAll(compiledDescItems.AdditionalForgeables);
compiled.FilterSpecCompiled.TraverseFilterBooleanExpr(
node => validationEnv.FilterBooleanExpressions.Add(node));
item.FilterPlan = compiled.FilterSpecCompiled.Parameters;
}
}
else if (contextSpec is ContextSpecHash) {
var hashed = (ContextSpecHash) contextSpec;
foreach (var hashItem in hashed.Items) {
var raw = new FilterStreamSpecRaw(
hashItem.FilterSpecRaw,
ViewSpec.EMPTY_VIEWSPEC_ARRAY,
null,
StreamSpecOptions.DEFAULT);
ValidateNotTable(hashItem.FilterSpecRaw.EventTypeName, validationEnv.Services);
var compiledDesc = StreamSpecCompiler.Compile(
raw,
eventTypesReferenced,
false,
false,
true,
false,
null,
0,
validationEnv.StatementRawInfo,
validationEnv.Services);
additionalForgeables.AddAll(compiledDesc.AdditionalForgeables);
var result = (FilterStreamSpecCompiled) compiledDesc.StreamSpecCompiled;
validationEnv.FilterSpecCompileds.Add(result.FilterSpecCompiled);
hashItem.FilterSpecCompiled = result.FilterSpecCompiled;
// validate parameters
var streamTypes = new StreamTypeServiceImpl(
result.FilterSpecCompiled.FilterForEventType,
null,
true);
var validationContext =
new ExprValidationContextBuilder(
streamTypes,
validationEnv.StatementRawInfo,
validationEnv.Services)
.WithIsFilterExpression(true)
.Build();
ExprNodeUtilityValidate.Validate(
ExprNodeOrigin.CONTEXT,
Collections.SingletonList(hashItem.Function),
validationContext);
}
}
else if (contextSpec is ContextSpecInitiatedTerminated) {
var def = (ContextSpecInitiatedTerminated) contextSpec;
var startCondition = ValidateRewriteContextCondition(
true,
nestingLevel,
def.StartCondition,
eventTypesReferenced,
new MatchEventSpec(),
new LinkedHashSet<string>(),
validationEnv);
additionalForgeables.AddAll(startCondition.AdditionalForgeables);
var endCondition = ValidateRewriteContextCondition(
false,
nestingLevel,
def.EndCondition,
eventTypesReferenced,
startCondition.Matches,
startCondition.AllTags,
validationEnv);
additionalForgeables.AddAll(endCondition.AdditionalForgeables);
def.StartCondition = startCondition.Condition;
def.EndCondition = endCondition.Condition;
if (def.DistinctExpressions != null) {
if (!(startCondition.Condition is ContextSpecConditionFilter)) {
throw new ExprValidationException(
"Distinct-expressions require a stream as the initiated-by condition");
}
var distinctExpressions = def.DistinctExpressions;
if (distinctExpressions.Length == 0) {
throw new ExprValidationException("Distinct-expressions have not been provided");
}
var filter = (ContextSpecConditionFilter) startCondition.Condition;
if (filter.OptionalFilterAsName == null) {
throw new ExprValidationException(
"Distinct-expressions require that a stream name is assigned to the stream using 'as'");
}
var types = new StreamTypeServiceImpl(
filter.FilterSpecCompiled.FilterForEventType,
filter.OptionalFilterAsName,
true);
var validationContext =
new ExprValidationContextBuilder(types, validationEnv.StatementRawInfo, validationEnv.Services)
.WithAllowBindingConsumption(true)
.Build();
for (var i = 0; i < distinctExpressions.Length; i++) {
ExprNodeUtilityValidate.ValidatePlainExpression(
ExprNodeOrigin.CONTEXTDISTINCT,
distinctExpressions[i]);
distinctExpressions[i] = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.CONTEXTDISTINCT,
distinctExpressions[i],
validationContext);
}
var multiKeyPlan = MultiKeyPlanner.PlanMultiKey(
distinctExpressions,
false,
@base.StatementRawInfo,
validationEnv.Services.SerdeResolver);
def.DistinctMultiKey = multiKeyPlan.ClassRef;
additionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables);
}
}
else if (contextSpec is ContextNested) {
var nested = (ContextNested) contextSpec;
var level = 0;
ISet<string> namesUsed = new HashSet<string>();
namesUsed.Add(validationEnv.ContextName);
foreach (var nestedContext in nested.Contexts) {
if (namesUsed.Contains(nestedContext.ContextName)) {
throw new ExprValidationException(
"Context by name '" +
nestedContext.ContextName +
"' has already been declared within nested context '" +
validationEnv.ContextName +
"'");
}
namesUsed.Add(nestedContext.ContextName);
var forgeables = ValidateContextDetail(nestedContext.ContextDetail, level, validationEnv);
additionalForgeables.AddAll(forgeables);
level++;
}
}
else {
throw new IllegalStateException("Unrecognized context detail " + contextSpec);
}
return additionalForgeables;
}
public TimeBoundaryQueryDescriptor()
{
ContextValue = new ContextSpec();
}
public static IList<ExprNode> CollectExpressionsShallow(StatementSpecRaw raw)
{
IList<ExprNode> expressions = new List<ExprNode>();
if (raw.CreateContextDesc != null) {
ContextSpec detail = raw.CreateContextDesc.ContextDetail;
if (detail is ContextSpecKeyed) {
var ks = (ContextSpecKeyed) detail;
foreach (ContextSpecKeyedItem item in ks.Items) {
if (item.FilterSpecRaw.FilterExpressions != null) {
expressions.AddAll(item.FilterSpecRaw.FilterExpressions);
}
}
if (ks.OptionalInit != null) {
foreach (ContextSpecConditionFilter filter in ks.OptionalInit) {
CollectExpressions(expressions, filter);
}
}
if (ks.OptionalTermination != null) {
CollectExpressions(expressions, ks.OptionalTermination);
}
}
else if (detail is ContextSpecCategory) {
var cat = (ContextSpecCategory) detail;
foreach (var item in cat.Items) {
if (item.Expression != null) {
expressions.Add(item.Expression);
}
}
if (cat.FilterSpecRaw.FilterExpressions != null) {
expressions.AddAll(cat.FilterSpecRaw.FilterExpressions);
}
}
else if (detail is ContextSpecInitiatedTerminated) {
var ts = (ContextSpecInitiatedTerminated) detail;
CollectExpressions(expressions, ts.StartCondition);
CollectExpressions(expressions, ts.EndCondition);
}
else {
throw new EPException("Failed to obtain expressions from context detail " + detail);
}
}
if (raw.CreateVariableDesc != null) {
var expr = raw.CreateVariableDesc.Assignment;
if (expr != null) {
expressions.Add(expr);
}
}
if (raw.CreateWindowDesc != null) {
var expr = raw.CreateWindowDesc.InsertFilter;
if (expr != null) {
expressions.Add(expr);
}
foreach (var view in raw.CreateWindowDesc.ViewSpecs) {
expressions.AddAll(view.ObjectParameters);
}
}
if (raw.UpdateDesc != null) {
if (raw.UpdateDesc.OptionalWhereClause != null) {
expressions.Add(raw.UpdateDesc.OptionalWhereClause);
}
if (raw.UpdateDesc.Assignments != null) {
foreach (var pair in raw.UpdateDesc.Assignments) {
expressions.Add(pair.Expression);
}
}
}
// on-expr
if (raw.OnTriggerDesc != null) {
if (raw.OnTriggerDesc is OnTriggerSplitStreamDesc) {
var onSplit = (OnTriggerSplitStreamDesc) raw.OnTriggerDesc;
foreach (var item in onSplit.SplitStreams) {
if (item.SelectClause != null) {
AddSelectClause(expressions, item.SelectClause.SelectExprList);
}
if (item.WhereClause != null) {
expressions.Add(item.WhereClause);
}
}
}
var onSet = raw.OnTriggerDesc as OnTriggerSetDesc;
if (onSet?.Assignments != null) {
foreach (var aitem in onSet.Assignments) {
expressions.Add(aitem.Expression);
}
}
var onUpdate = raw.OnTriggerDesc as OnTriggerWindowUpdateDesc;
if (onUpdate?.Assignments != null) {
foreach (var bitem in onUpdate.Assignments) {
expressions.Add(bitem.Expression);
}
}
if (raw.OnTriggerDesc is OnTriggerMergeDesc) {
var onMerge = (OnTriggerMergeDesc) raw.OnTriggerDesc;
foreach (var item in onMerge.Items) {
if (item.OptionalMatchCond != null) {
expressions.Add(item.OptionalMatchCond);
}
foreach (var action in item.Actions) {
if (action.OptionalWhereClause != null) {
expressions.Add(action.OptionalWhereClause);
}
if (action is OnTriggerMergeActionUpdate) {
var update = (OnTriggerMergeActionUpdate) action;
foreach (var assignment in update.Assignments) {
expressions.Add(assignment.Expression);
}
}
else if (action is OnTriggerMergeActionInsert) {
var insert = (OnTriggerMergeActionInsert) action;
AddSelectClause(expressions, insert.SelectClause);
}
}
}
if (onMerge.OptionalInsertNoMatch != null) {
AddSelectClause(expressions, onMerge.OptionalInsertNoMatch.SelectClause);
}
}
}
// select clause
if (raw.SelectClauseSpec != null) {
AddSelectClause(expressions, raw.SelectClauseSpec.SelectExprList);
}
// from clause
if (raw.StreamSpecs != null) {
foreach (var stream in raw.StreamSpecs) {
// filter stream
if (stream is FilterStreamSpecRaw) {
var filterStream = (FilterStreamSpecRaw) stream;
var filter = filterStream.RawFilterSpec;
if (filter != null && filter.FilterExpressions != null) {
expressions.AddAll(filter.FilterExpressions);
}
if (filter != null && filter.OptionalPropertyEvalSpec != null) {
foreach (var contained in filter.OptionalPropertyEvalSpec.Atoms) {
AddSelectClause(
expressions,
contained.OptionalSelectClause == null
? null
: contained.OptionalSelectClause.SelectExprList);
if (contained.OptionalWhereClause != null) {
expressions.Add(contained.OptionalWhereClause);
}
}
}
}
// pattern stream
if (stream is PatternStreamSpecRaw) {
var patternStream = (PatternStreamSpecRaw) stream;
CollectPatternExpressions(expressions, patternStream.EvalForgeNode);
}
// method stream
var methodStream = stream as MethodStreamSpec;
if (methodStream?.Expressions != null) {
expressions.AddAll(methodStream.Expressions);
}
if (stream.ViewSpecs != null) {
foreach (var view in stream.ViewSpecs) {
expressions.AddAll(view.ObjectParameters);
}
}
}
if (raw.OuterJoinDescList != null) {
foreach (var q in raw.OuterJoinDescList) {
if (q.OptLeftNode != null) {
expressions.Add(q.OptLeftNode);
expressions.Add(q.OptRightNode);
foreach (ExprIdentNode ident in q.AdditionalLeftNodes) {
expressions.Add(ident);
}
foreach (ExprIdentNode ident in q.AdditionalRightNodes) {
expressions.Add(ident);
}
}
}
}
}
if (raw.WhereClause != null) {
expressions.Add(raw.WhereClause);
}
if (raw.GroupByExpressions != null) {
foreach (var element in raw.GroupByExpressions) {
if (element is GroupByClauseElementExpr) {
expressions.Add(((GroupByClauseElementExpr) element).Expr);
}
else if (element is GroupByClauseElementRollupOrCube) {
var rollup = (GroupByClauseElementRollupOrCube) element;
AnalyzeRollup(rollup, expressions);
}
else {
var set = (GroupByClauseElementGroupingSet) element;
foreach (var inner in set.Elements) {
if (inner is GroupByClauseElementExpr) {
expressions.Add(((GroupByClauseElementExpr) inner).Expr);
}
else if (inner is GroupByClauseElementCombinedExpr) {
expressions.AddAll(((GroupByClauseElementCombinedExpr) inner).Expressions);
}
else {
AnalyzeRollup((GroupByClauseElementRollupOrCube) inner, expressions);
}
}
}
}
}
if (raw.HavingClause != null) {
expressions.Add(raw.HavingClause);
}
if (raw.OutputLimitSpec != null) {
if (raw.OutputLimitSpec.WhenExpressionNode != null) {
expressions.Add(raw.OutputLimitSpec.WhenExpressionNode);
}
if (raw.OutputLimitSpec.ThenExpressions != null) {
foreach (var thenAssign in raw.OutputLimitSpec.ThenExpressions) {
expressions.Add(thenAssign.Expression);
}
}
if (raw.OutputLimitSpec.CrontabAtSchedule != null) {
expressions.AddAll(raw.OutputLimitSpec.CrontabAtSchedule);
}
if (raw.OutputLimitSpec.TimePeriodExpr != null) {
expressions.Add(raw.OutputLimitSpec.TimePeriodExpr);
}
if (raw.OutputLimitSpec.AfterTimePeriodExpr != null) {
expressions.Add(raw.OutputLimitSpec.AfterTimePeriodExpr);
}
}
if (raw.OrderByList != null) {
foreach (var orderByElement in raw.OrderByList) {
expressions.Add(orderByElement.ExprNode);
}
}
if (raw.MatchRecognizeSpec != null) {
if (raw.MatchRecognizeSpec.PartitionByExpressions != null) {
expressions.AddAll(raw.MatchRecognizeSpec.PartitionByExpressions);
}
foreach (var selectItemMR in raw.MatchRecognizeSpec.Measures) {
expressions.Add(selectItemMR.Expr);
}
foreach (var define in raw.MatchRecognizeSpec.Defines) {
expressions.Add(define.Expression);
}
if (raw.MatchRecognizeSpec.Interval?.TimePeriodExpr != null) {
expressions.Add(raw.MatchRecognizeSpec.Interval.TimePeriodExpr);
}
}
if (raw.ForClauseSpec != null) {
foreach (var item in raw.ForClauseSpec.Clauses) {
if (item.Expressions != null) {
expressions.AddAll(item.Expressions);
}
}
}
return expressions;
}
