public override void Validate(
ExprNodeOrigin origin,
ExprValidationContext validationContext)
{
Expression = GetValidatedSubtree(origin, Expression, validationContext);
EPStatementStartMethodHelperValidate.ValidateNoAggregations(Expression, ValidationAggMsg);
}
protected override void InitExec(
string aliasName,
StatementSpecCompiled spec,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
StreamTypeServiceImpl assignmentTypeService = new StreamTypeServiceImpl(
new EventType[] {
processor.EventTypeRspInputEvents, null,
processor.EventTypeRspInputEvents
},
new string[] {aliasName, "", INITIAL_VALUE_STREAM_NAME},
new bool[] {true, true, true},
true,
false);
assignmentTypeService.IsStreamZeroUnambigous = true;
ExprValidationContext validationContext =
new ExprValidationContextBuilder(assignmentTypeService, statementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
// validate update expressions
FireAndForgetSpecUpdate updateSpec = (FireAndForgetSpecUpdate) spec.Raw.FireAndForgetSpec;
try {
foreach (OnTriggerSetAssignment assignment in updateSpec.Assignments) {
ExprNode validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.UPDATEASSIGN,
assignment.Expression,
validationContext);
assignment.Expression = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(
validated,
"Aggregation functions may not be used within an update-clause");
}
}
catch (ExprValidationException e) {
throw new EPException(e.Message, e);
}
// make updater
//TableUpdateStrategy tableUpdateStrategy = null;
try {
bool copyOnWrite = processor is FireAndForgetProcessorNamedWindowForge;
updateHelper = EventBeanUpdateHelperForgeFactory.Make(
processor.NamedWindowOrTableName,
(EventTypeSPI) processor.EventTypeRspInputEvents,
updateSpec.Assignments,
aliasName,
null,
copyOnWrite,
statementRawInfo.StatementName,
services.EventTypeAvroHandler);
}
catch (ExprValidationException e) {
throw new EPException(e.Message, e);
}
}
public override void Validate(
ExprNodeOrigin origin,
ExprValidationContext validationContext)
{
var index = _indexExpressions[0];
index = ExprNodeUtilityValidate.GetValidatedSubtree(origin, index, validationContext);
_indexExpressions = Collections.SingletonList(index);
ChainableArray.ValidateSingleIndexExpr(_indexExpressions, () => "expression '" + Ident + "'");
EPStatementStartMethodHelperValidate.ValidateNoAggregations(index, ExprAssignment.ValidationAggMsg);
}
private static OnSplitItemForge OnSplitValidate(
StreamTypeService typeServiceTrigger,
StatementSpecCompiled statementSpecCompiled,
ContextPropertyRegistry contextPropertyRegistry,
PropertyEvaluatorForge optionalPropertyEval,
StatementRawInfo rawInfo,
StatementCompileTimeServices services)
{
var insertIntoName = statementSpecCompiled.Raw.InsertIntoDesc.EventTypeName;
var isNamedWindowInsert = services.NamedWindowCompileTimeResolver.Resolve(insertIntoName) != null;
var table = services.TableCompileTimeResolver.Resolve(insertIntoName);
EPStatementStartMethodHelperValidate.ValidateNodes(
statementSpecCompiled.Raw,
typeServiceTrigger,
null,
rawInfo,
services);
var spec = new ResultSetSpec(statementSpecCompiled);
var factoryDescs = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
spec,
typeServiceTrigger,
null,
new bool[0],
false,
contextPropertyRegistry,
false,
true,
rawInfo,
services);
return new OnSplitItemForge(
statementSpecCompiled.Raw.WhereClause,
isNamedWindowInsert,
table,
factoryDescs,
optionalPropertyEval);
}
public StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var statementSpec = @base.StatementSpec;
// determine context
var contextName = @base.StatementSpec.Raw.OptionalContextName;
if (contextName != null) {
throw new ExprValidationException("Update IStream is not supported in conjunction with a context");
}
var streamSpec = statementSpec.StreamSpecs[0];
var updateSpec = statementSpec.Raw.UpdateDesc;
string triggereventTypeName;
EventType streamEventType;
if (streamSpec is FilterStreamSpecCompiled) {
var filterStreamSpec = (FilterStreamSpecCompiled) streamSpec;
triggereventTypeName = filterStreamSpec.FilterSpecCompiled.FilterForEventTypeName;
streamEventType = filterStreamSpec.FilterSpecCompiled.FilterForEventType;
}
else if (streamSpec is NamedWindowConsumerStreamSpec) {
var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec;
streamEventType = namedSpec.NamedWindow.EventType;
triggereventTypeName = streamEventType.Name;
}
else if (streamSpec is TableQueryStreamSpec) {
throw new ExprValidationException("Tables cannot be used in an update-istream statement");
}
else {
throw new ExprValidationException("Unknown stream specification streamEventType: " + streamSpec);
}
// determine a stream name
var streamName = triggereventTypeName;
if (updateSpec.OptionalStreamName != null) {
streamName = updateSpec.OptionalStreamName;
}
StreamTypeService typeService = new StreamTypeServiceImpl(
new[] {streamEventType},
new[] {streamName},
new[] {true},
false,
false);
// create subselect information
IList<FilterSpecCompiled> filterSpecCompileds = new List<FilterSpecCompiled>();
IList<NamedWindowConsumerStreamSpec> namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
var subselectActivation = SubSelectHelperActivations.CreateSubSelectActivation(
filterSpecCompileds,
namedWindowConsumers,
@base,
services);
// handle subselects
var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect(
@base,
subselectActivation,
typeService.StreamNames,
typeService.EventTypes,
new[] {triggereventTypeName},
services);
var validationContext =
new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services).Build();
foreach (var assignment in updateSpec.Assignments) {
var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext);
assignment.Expression = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(
validated,
"Aggregation functions may not be used within an update-clause");
}
if (updateSpec.OptionalWhereClause != null) {
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.WHERE,
updateSpec.OptionalWhereClause,
validationContext);
updateSpec.OptionalWhereClause = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(
validated,
"Aggregation functions may not be used within an update-clause");
}
// build route information
var routerDesc = InternalEventRouterDescFactory.GetValidatePreprocessing(
streamEventType,
updateSpec,
@base.StatementRawInfo.Annotations);
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var packageScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var forge = new StatementAgentInstanceFactoryUpdateForge(routerDesc, subselectForges);
var aiFactoryForgable = new StmtClassForgableAIFactoryProviderUpdate(
aiFactoryProviderClassName,
packageScope,
forge);
var selectSubscriberDescriptor = new SelectSubscriberDescriptor(
new[] {streamEventType.UnderlyingType},
new[] {"*"},
false,
null);
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
filterSpecCompileds,
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(),
false,
selectSubscriberDescriptor,
packageScope,
services);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var stmtProvider = new StmtClassForgableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
packageScope);
IList<StmtClassForgable> forgables = new List<StmtClassForgable>();
forgables.Add(aiFactoryForgable);
forgables.Add(stmtProvider);
forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 0));
return new StmtForgeMethodResult(
forgables,
filterSpecCompileds,
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
namedWindowConsumers,
Collections.GetEmptyList<FilterSpecParamExprNodeForge>());
}
private static void HandleSubselectSelectClauses(
int subselectStreamNumber,
StatementContext statementContext,
ExprSubselectNode subselect,
EventType outerEventType,
string outerEventTypeName,
string outerStreamName,
IDictionary <string, Pair <EventType, string> > taggedEventTypes,
IDictionary <string, Pair <EventType, string> > arrayEventTypes)
{
var statementSpec = subselect.StatementSpecCompiled;
var filterStreamSpec = statementSpec.StreamSpecs[0];
ViewFactoryChain viewFactoryChain;
string subselecteventTypeName = null;
// construct view factory chain
try {
if (statementSpec.StreamSpecs[0] is FilterStreamSpecCompiled)
{
var filterStreamSpecCompiled = (FilterStreamSpecCompiled)statementSpec.StreamSpecs[0];
subselecteventTypeName = filterStreamSpecCompiled.FilterSpec.FilterForEventTypeName;
// A child view is required to limit the stream
if (filterStreamSpec.ViewSpecs.Length == 0)
{
throw new ExprValidationException("Subqueries require one or more views to limit the stream, consider declaring a length or time window");
}
// Register filter, create view factories
viewFactoryChain = statementContext.ViewService.CreateFactories(subselectStreamNumber, filterStreamSpecCompiled.FilterSpec.ResultEventType, filterStreamSpec.ViewSpecs, filterStreamSpec.Options, statementContext);
subselect.RawEventType = viewFactoryChain.EventType;
}
else
{
var namedSpec = (NamedWindowConsumerStreamSpec)statementSpec.StreamSpecs[0];
var processor = statementContext.NamedWindowService.GetProcessor(namedSpec.WindowName);
viewFactoryChain = statementContext.ViewService.CreateFactories(0, processor.NamedWindowType, namedSpec.ViewSpecs, namedSpec.Options, statementContext);
subselecteventTypeName = namedSpec.WindowName;
EPLValidationUtil.ValidateContextName(false, processor.NamedWindowName, processor.ContextName, statementContext.ContextName, true);
}
}
catch (ViewProcessingException ex) {
throw new ExprValidationException("Error validating subexpression: " + ex.Message, ex);
}
// the final event type
var eventType = viewFactoryChain.EventType;
// determine a stream name unless one was supplied
var subexpressionStreamName = filterStreamSpec.OptionalStreamName;
if (subexpressionStreamName == null)
{
subexpressionStreamName = "$subselect_" + subselectStreamNumber;
}
// Named windows don't allow data views
if (filterStreamSpec is NamedWindowConsumerStreamSpec)
{
EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(viewFactoryChain.FactoryChain);
}
// Streams event types are the original stream types with the stream zero the subselect stream
var namesAndTypes = new LinkedHashMap <string, Pair <EventType, string> >();
namesAndTypes.Put(subexpressionStreamName, new Pair <EventType, string>(eventType, subselecteventTypeName));
namesAndTypes.Put(outerStreamName, new Pair <EventType, string>(outerEventType, outerEventTypeName));
if (taggedEventTypes != null)
{
foreach (KeyValuePair <string, Pair <EventType, string> > entry in taggedEventTypes)
{
namesAndTypes.Put(entry.Key, new Pair <EventType, string>(entry.Value.First, entry.Value.Second));
}
}
if (arrayEventTypes != null)
{
foreach (KeyValuePair <string, Pair <EventType, string> > entry in arrayEventTypes)
{
namesAndTypes.Put(entry.Key, new Pair <EventType, string>(entry.Value.First, entry.Value.Second));
}
}
StreamTypeService subselectTypeService = new StreamTypeServiceImpl(namesAndTypes, statementContext.EngineURI, true, true);
var viewResourceDelegateSubselect = new ViewResourceDelegateUnverified();
subselect.FilterSubqueryStreamTypes = subselectTypeService;
// Validate select expression
var selectClauseSpec = subselect.StatementSpecCompiled.SelectClauseSpec;
if (selectClauseSpec.SelectExprList.Length > 0)
{
if (selectClauseSpec.SelectExprList.Length > 1)
{
throw new ExprValidationException("Subquery multi-column select is not allowed in this context.");
}
var element = selectClauseSpec.SelectExprList[0];
if (element is SelectClauseExprCompiledSpec)
{
// validate
var compiled = (SelectClauseExprCompiledSpec)element;
var selectExpression = compiled.SelectExpression;
var evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
var validationContext = new ExprValidationContext(
subselectTypeService, statementContext.MethodResolutionService, viewResourceDelegateSubselect,
statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService,
evaluatorContextStmt, statementContext.EventAdapterService, statementContext.StatementName,
statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, true, false, null, false);
selectExpression = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.SUBQUERYSELECT, selectExpression, validationContext);
subselect.SelectClause = new ExprNode[] { selectExpression };
subselect.SelectAsNames = new string[] { compiled.AssignedName };
// handle aggregation
var aggExprNodes = new List <ExprAggregateNode>();
ExprAggregateNodeUtil.GetAggregatesBottomUp(selectExpression, aggExprNodes);
if (aggExprNodes.Count > 0)
{
// Other stream properties, if there is aggregation, cannot be under aggregation.
foreach (var aggNode in aggExprNodes)
{
var propertiesNodesAggregated = ExprNodeUtility.GetExpressionProperties(aggNode, true);
foreach (var pair in propertiesNodesAggregated)
{
if (pair.First != 0)
{
throw new ExprValidationException("Subselect aggregation function cannot aggregate across correlated properties");
}
}
}
// This stream (stream 0) properties must either all be under aggregation, or all not be.
var propertiesNotAggregated = ExprNodeUtility.GetExpressionProperties(selectExpression, false);
foreach (var pair in propertiesNotAggregated)
{
if (pair.First == 0)
{
throw new ExprValidationException("Subselect properties must all be within aggregation functions");
}
}
}
}
}
}
public static IList <StmtClassForgeableFactory> HandleSubselectSelectClauses(
ExprSubselectNode subselect,
EventType outerEventType,
string outerEventTypeName,
string outerStreamName,
IDictionary <string, Pair <EventType, string> > taggedEventTypes,
IDictionary <string, Pair <EventType, string> > arrayEventTypes,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
if (subselect.SubselectNumber == -1)
{
throw new IllegalStateException("Subselect is unassigned");
}
var statementSpec = subselect.StatementSpecCompiled;
var filterStreamSpec = statementSpec.StreamSpecs[0];
IList <ViewFactoryForge> viewForges;
string subselecteventTypeName;
IList <StmtClassForgeableFactory> additionalForgeables;
// construct view factory chain
EventType eventType;
try {
var args = new ViewFactoryForgeArgs(
-1,
true,
subselect.SubselectNumber,
StreamSpecOptions.DEFAULT,
null,
statementRawInfo,
services);
var streamSpec = statementSpec.StreamSpecs[0];
if (streamSpec is FilterStreamSpecCompiled)
{
var filterStreamSpecCompiled = (FilterStreamSpecCompiled)statementSpec.StreamSpecs[0];
subselecteventTypeName = filterStreamSpecCompiled.FilterSpecCompiled.FilterForEventTypeName;
// A child view is required to limit the stream
if (filterStreamSpec.ViewSpecs.Length == 0)
{
throw new ExprValidationException(
"Subqueries require one or more views to limit the stream, consider declaring a length or time window");
}
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(
filterStreamSpecCompiled.ViewSpecs,
args,
filterStreamSpecCompiled.FilterSpecCompiled.ResultEventType);
viewForges = viewForgeDesc.Forges;
additionalForgeables = viewForgeDesc.MultikeyForges;
// Register filter, create view factories
eventType = viewForges.IsEmpty() ? filterStreamSpecCompiled.FilterSpecCompiled.ResultEventType : viewForges[viewForges.Count - 1].EventType;
subselect.RawEventType = eventType;
}
else if (streamSpec is NamedWindowConsumerStreamSpec)
{
var namedSpec = (NamedWindowConsumerStreamSpec)statementSpec.StreamSpecs[0];
var namedWindow = namedSpec.NamedWindow;
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(namedSpec.ViewSpecs, args, namedWindow.EventType);
viewForges = viewForgeDesc.Forges;
additionalForgeables = viewForgeDesc.MultikeyForges;
var namedWindowName = namedWindow.EventType.Name;
subselecteventTypeName = namedWindowName;
EPLValidationUtil.ValidateContextName(false, namedWindowName, namedWindow.ContextName, statementRawInfo.ContextName, true);
subselect.RawEventType = namedWindow.EventType;
eventType = namedWindow.EventType;
}
else if (streamSpec is TableQueryStreamSpec)
{
var namedSpec = (TableQueryStreamSpec)statementSpec.StreamSpecs[0];
var table = namedSpec.Table;
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(namedSpec.ViewSpecs, args, table.InternalEventType);
viewForges = viewForgeDesc.Forges;
additionalForgeables = viewForgeDesc.MultikeyForges;
var namedWindowName = table.TableName;
subselecteventTypeName = namedWindowName;
EPLValidationUtil.ValidateContextName(false, namedWindowName, table.OptionalContextName, statementRawInfo.ContextName, true);
subselect.RawEventType = table.InternalEventType;
eventType = table.InternalEventType;
}
else
{
throw new IllegalStateException("Unexpected stream spec " + streamSpec);
}
}
catch (ViewProcessingException ex) {
throw new ExprValidationException("Failed to validate subexpression: " + ex.Message, ex);
}
// determine a stream name unless one was supplied
var subexpressionStreamName = SubselectUtil.GetStreamName(filterStreamSpec.OptionalStreamName, subselect.SubselectNumber);
// Named windows don't allow data views
if (filterStreamSpec is NamedWindowConsumerStreamSpec | filterStreamSpec is TableQueryStreamSpec)
{
EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(viewForges);
}
// Streams event types are the original stream types with the stream zero the subselect stream
var namesAndTypes = new LinkedHashMap <string, Pair <EventType, string> >();
namesAndTypes.Put(subexpressionStreamName, new Pair <EventType, string>(eventType, subselecteventTypeName));
namesAndTypes.Put(outerStreamName, new Pair <EventType, string>(outerEventType, outerEventTypeName));
if (taggedEventTypes != null)
{
foreach (var entry in taggedEventTypes)
{
namesAndTypes.Put(entry.Key, new Pair <EventType, string>(entry.Value.First, entry.Value.Second));
}
}
if (arrayEventTypes != null)
{
foreach (var entry in arrayEventTypes)
{
namesAndTypes.Put(entry.Key, new Pair <EventType, string>(entry.Value.First, entry.Value.Second));
}
}
StreamTypeService subselectTypeService = new StreamTypeServiceImpl(namesAndTypes, true, true);
var viewResourceDelegateSubselect = new ViewResourceDelegateExpr();
subselect.FilterSubqueryStreamTypes = subselectTypeService;
// Validate select expression
var selectClauseSpec = subselect.StatementSpecCompiled.SelectClauseCompiled;
if (selectClauseSpec.SelectExprList.Length > 0)
{
if (selectClauseSpec.SelectExprList.Length > 1)
{
throw new ExprValidationException("Subquery multi-column select is not allowed in this context.");
}
var element = selectClauseSpec.SelectExprList[0];
if (element is SelectClauseExprCompiledSpec)
{
// validate
var compiled = (SelectClauseExprCompiledSpec)element;
var selectExpression = compiled.SelectExpression;
var validationContext = new ExprValidationContextBuilder(subselectTypeService, statementRawInfo, services)
.WithViewResourceDelegate(viewResourceDelegateSubselect)
.WithAllowBindingConsumption(true)
.WithMemberName(new ExprValidationMemberNameQualifiedSubquery(subselect.SubselectNumber))
.Build();
selectExpression = ExprNodeUtilityValidate.GetValidatedSubtree(ExprNodeOrigin.SUBQUERYSELECT, selectExpression, validationContext);
subselect.SelectClause = new ExprNode[] { selectExpression };
subselect.SelectAsNames = new string[] { compiled.AssignedName };
// handle aggregation
var aggExprNodes = new List <ExprAggregateNode>();
ExprAggregateNodeUtil.GetAggregatesBottomUp(selectExpression, aggExprNodes);
if (aggExprNodes.Count > 0)
{
// Other stream properties, if there is aggregation, cannot be under aggregation.
foreach (var aggNode in aggExprNodes)
{
var propertiesNodesAggregated = ExprNodeUtilityQuery.GetExpressionProperties(aggNode, true);
foreach (var pair in propertiesNodesAggregated)
{
if (pair.First != 0)
{
throw new ExprValidationException("Subselect aggregation function cannot aggregate across correlated properties");
}
}
}
// This stream (stream 0) properties must either all be under aggregation, or all not be.
var propertiesNotAggregated = ExprNodeUtilityQuery.GetExpressionProperties(selectExpression, false);
foreach (var pair in propertiesNotAggregated)
{
if (pair.First == 0)
{
throw new ExprValidationException("Subselect properties must all be within aggregation functions");
}
}
}
}
}
return(additionalForgeables);
}
private static IList<SelectClauseElementCompiled> ValidateInsertSelect(
IList<SelectClauseElementRaw> selectClause,
StreamTypeService insertTypeSvc,
IList<string> insertColumns,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var colIndex = 0;
IList<SelectClauseElementCompiled> compiledSelect = new List<SelectClauseElementCompiled>();
foreach (var raw in selectClause) {
if (raw is SelectClauseStreamRawSpec) {
var rawStreamSpec = (SelectClauseStreamRawSpec) raw;
int? foundStreamNum = null;
for (var s = 0; s < insertTypeSvc.StreamNames.Length; s++) {
if (rawStreamSpec.StreamName.Equals(insertTypeSvc.StreamNames[s])) {
foundStreamNum = s;
break;
}
}
if (foundStreamNum == null) {
throw new ExprValidationException(
"Stream by name '" + rawStreamSpec.StreamName + "' was not found");
}
var streamSelectSpec = new SelectClauseStreamCompiledSpec(
rawStreamSpec.StreamName,
rawStreamSpec.OptionalAsName);
streamSelectSpec.StreamNumber = foundStreamNum.Value;
compiledSelect.Add(streamSelectSpec);
}
else if (raw is SelectClauseExprRawSpec) {
var exprSpec = (SelectClauseExprRawSpec) raw;
var validationContext = new ExprValidationContextBuilder(insertTypeSvc, statementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
var exprCompiled = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.SELECT,
exprSpec.SelectExpression,
validationContext);
var resultName = exprSpec.OptionalAsName;
if (resultName == null) {
if (insertColumns.Count > colIndex) {
resultName = insertColumns[colIndex];
}
else {
resultName = ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprCompiled);
}
}
compiledSelect.Add(
new SelectClauseExprCompiledSpec(
exprCompiled,
resultName,
exprSpec.OptionalAsName,
exprSpec.IsEvents));
EPStatementStartMethodHelperValidate.ValidateNoAggregations(
exprCompiled,
"Expression in a merge-selection may not utilize aggregation functions");
}
else if (raw is SelectClauseElementWildcard) {
compiledSelect.Add(new SelectClauseElementWildcard());
}
else {
throw new IllegalStateException("Unknown select clause item:" + raw);
}
colIndex++;
}
return compiledSelect;
}
public static OnTriggerPlanValidationResult ValidateOnTriggerPlan(
EventType namedWindowOrTableType,
OnTriggerWindowDesc onTriggerDesc,
StreamSpecCompiled streamSpec,
OnTriggerActivatorDesc activatorResult,
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var zeroStreamAliasName = onTriggerDesc.OptionalAsName;
if (zeroStreamAliasName == null) {
zeroStreamAliasName = "stream_0";
}
var streamName = streamSpec.OptionalStreamName;
if (streamName == null) {
streamName = "stream_1";
}
var namedWindowTypeName = onTriggerDesc.WindowName;
// Materialize sub-select views
// 0 - named window stream
// 1 - arriving stream
// 2 - initial value before update
string[] subselectStreamNames = {zeroStreamAliasName, streamSpec.OptionalStreamName};
EventType[] subselectEventTypes = {namedWindowOrTableType, activatorResult.ActivatorResultEventType};
string[] subselectEventTypeNames = {namedWindowTypeName, activatorResult.TriggerEventTypeName};
var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect(
@base,
subselectActivation,
subselectStreamNames,
subselectEventTypes,
subselectEventTypeNames,
services);
var typeService = new StreamTypeServiceImpl(
new[] {namedWindowOrTableType, activatorResult.ActivatorResultEventType},
new[] {zeroStreamAliasName, streamName},
new[] {false, true},
true,
false);
// allow "initial" as a prefix to properties
StreamTypeServiceImpl assignmentTypeService;
if (zeroStreamAliasName.Equals(INITIAL_VALUE_STREAM_NAME) || streamName.Equals(INITIAL_VALUE_STREAM_NAME)) {
assignmentTypeService = typeService;
}
else {
assignmentTypeService = new StreamTypeServiceImpl(
new[] {namedWindowOrTableType, activatorResult.ActivatorResultEventType, namedWindowOrTableType},
new[] {zeroStreamAliasName, streamName, INITIAL_VALUE_STREAM_NAME},
new[] {false, true, true},
false,
false);
assignmentTypeService.IsStreamZeroUnambigous = true;
}
if (onTriggerDesc is OnTriggerWindowUpdateDesc) {
var updateDesc = (OnTriggerWindowUpdateDesc) onTriggerDesc;
var validationContext = new ExprValidationContextBuilder(
assignmentTypeService,
@base.StatementRawInfo,
services)
.WithAllowBindingConsumption(true)
.Build();
foreach (var assignment in updateDesc.Assignments) {
var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext);
assignment.Expression = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(
validated,
"Aggregation functions may not be used within an on-update-clause");
}
}
if (onTriggerDesc is OnTriggerMergeDesc) {
var mergeDesc = (OnTriggerMergeDesc) onTriggerDesc;
ValidateMergeDesc(
mergeDesc,
namedWindowOrTableType,
zeroStreamAliasName,
activatorResult.ActivatorResultEventType,
streamName,
@base.StatementRawInfo,
services);
}
// validate join expression
var validatedJoin = ValidateJoinNamedWindow(
ExprNodeOrigin.WHERE,
@base.StatementSpec.Raw.WhereClause,
namedWindowOrTableType,
zeroStreamAliasName,
namedWindowTypeName,
activatorResult.ActivatorResultEventType,
streamName,
activatorResult.TriggerEventTypeName,
null,
@base.StatementRawInfo,
services);
// validate filter, output rate limiting
EPStatementStartMethodHelperValidate.ValidateNodes(
@base.StatementSpec.Raw,
typeService,
null,
@base.StatementRawInfo,
services);
// Construct a processor for results; for use in on-select to process selection results
// Use a wildcard select if the select-clause is empty, such as for on-delete.
// For on-select the select clause is not empty.
if (@base.StatementSpec.SelectClauseCompiled.SelectExprList.Length == 0) {
@base.StatementSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard());
}
var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(@base.StatementSpec),
typeService,
null,
new bool[0],
true,
@base.ContextPropertyRegistry,
false,
true,
@base.StatementRawInfo,
services);
// plan table access
var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes);
return new OnTriggerPlanValidationResult(
subselectForges,
tableAccessForges,
resultSetProcessorPrototype,
validatedJoin,
zeroStreamAliasName);
}
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 StmtForgeMethodSelectResult Make(
IContainer container,
bool dataflowOperator,
string @namespace,
string classPostfix,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var filterSpecCompileds = new List<FilterSpecCompiled>();
var scheduleHandleCallbackProviders = new List<ScheduleHandleCallbackProvider>();
var namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
var statementSpec = @base.StatementSpec;
var additionalForgeables = new List<StmtClassForgeableFactory>();
var streamNames = StatementForgeMethodSelectUtil.DetermineStreamNames(statementSpec.StreamSpecs);
var numStreams = streamNames.Length;
if (numStreams == 0) {
throw new ExprValidationException("The from-clause is required but has not been specified");
}
// first we create streams for subselects, if there are any
SubSelectActivationDesc subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation(
filterSpecCompileds, namedWindowConsumers, @base, services);
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation = subSelectActivationDesc.Subselects;
additionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables);
// verify for joins that required views are present
StreamJoinAnalysisResultCompileTime joinAnalysisResult = StatementForgeMethodSelectUtil.VerifyJoinViews(statementSpec);
var streamEventTypes = new EventType[statementSpec.StreamSpecs.Length];
var eventTypeNames = new string[numStreams];
var isNamedWindow = new bool[numStreams];
var viewableActivatorForges = new ViewableActivatorForge[numStreams];
var viewForges = new IList<ViewFactoryForge>[numStreams];
var historicalEventViewables = new HistoricalEventViewableForge[numStreams];
for (var stream = 0; stream < numStreams; stream++) {
var streamSpec = statementSpec.StreamSpecs[stream];
var isCanIterateUnbound = streamSpec.ViewSpecs.Length == 0 &&
(services.Configuration.Compiler.ViewResources.IsIterableUnbound ||
AnnotationUtil.HasAnnotation(statementSpec.Annotations, typeof(IterableUnboundAttribute)));
var args = new ViewFactoryForgeArgs(
stream,
false,
-1,
streamSpec.Options,
null,
@base.StatementRawInfo,
services);
if (dataflowOperator) {
var dfResult = HandleDataflowActivation(args, streamSpec);
streamEventTypes[stream] = dfResult.StreamEventType;
eventTypeNames[stream] = dfResult.EventTypeName;
viewableActivatorForges[stream] = dfResult.ViewableActivatorForge;
viewForges[stream] = dfResult.ViewForges;
additionalForgeables.AddAll(dfResult.AdditionalForgeables);
}
else if (streamSpec is FilterStreamSpecCompiled) {
var filterStreamSpec = (FilterStreamSpecCompiled) statementSpec.StreamSpecs[stream];
var filterSpecCompiled = filterStreamSpec.FilterSpecCompiled;
streamEventTypes[stream] = filterSpecCompiled.ResultEventType;
eventTypeNames[stream] = filterStreamSpec.FilterSpecCompiled.FilterForEventTypeName;
viewableActivatorForges[stream] = new ViewableActivatorFilterForge(
filterSpecCompiled,
isCanIterateUnbound,
stream,
false,
-1);
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, streamEventTypes[stream]);
viewForges[stream] = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
filterSpecCompileds.Add(filterSpecCompiled);
}
else if (streamSpec is PatternStreamSpecCompiled) {
var patternStreamSpec = (PatternStreamSpecCompiled) streamSpec;
var forges = patternStreamSpec.Root.CollectFactories();
foreach (var forgeNode in forges) {
forgeNode.CollectSelfFilterAndSchedule(filterSpecCompileds, scheduleHandleCallbackProviders);
}
var patternType = ViewableActivatorPatternForge.MakeRegisterPatternType(
@base,
stream,
patternStreamSpec,
services);
var patternContext = new PatternContext(0, patternStreamSpec.MatchedEventMapMeta, false, -1, false);
viewableActivatorForges[stream] = new ViewableActivatorPatternForge(
patternType,
patternStreamSpec,
patternContext,
isCanIterateUnbound);
streamEventTypes[stream] = patternType;
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, patternType);
viewForges[stream] = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
}
else if (streamSpec is NamedWindowConsumerStreamSpec) {
var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec;
var namedWindow =
services.NamedWindowCompileTimeResolver.Resolve(namedSpec.NamedWindow.EventType.Name);
var namedWindowType = namedWindow.EventType;
if (namedSpec.OptPropertyEvaluator != null) {
namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
var typesFilterValidation = new StreamTypeServiceImpl(
namedWindowType,
namedSpec.OptionalStreamName,
false);
var filterSingle =
ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions);
var filterQueryGraph = EPLValidationUtil.ValidateFilterGetQueryGraphSafe(
filterSingle,
typesFilterValidation,
@base.StatementRawInfo,
services);
namedWindowConsumers.Add(namedSpec);
viewableActivatorForges[stream] = new ViewableActivatorNamedWindowForge(
namedSpec,
namedWindow,
filterSingle,
filterQueryGraph,
true,
namedSpec.OptPropertyEvaluator);
streamEventTypes[stream] = namedWindowType;
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
joinAnalysisResult.SetNamedWindowsPerStream(stream, namedWindow);
eventTypeNames[stream] = namedSpec.NamedWindow.EventType.Name;
isNamedWindow[stream] = true;
// Consumers to named windows cannot declare a data window view onto the named window to avoid duplicate remove streams
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType);
viewForges[stream] = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(viewForges[stream]);
}
else if (streamSpec is TableQueryStreamSpec) {
ValidateNoViews(streamSpec, "Table data");
var tableStreamSpec = (TableQueryStreamSpec) streamSpec;
if (numStreams > 1 && tableStreamSpec.FilterExpressions.Count > 0) {
throw new ExprValidationException(
"Joins with tables do not allow table filter expressions, please add table filters to the where-clause instead");
}
var table = tableStreamSpec.Table;
EPLValidationUtil.ValidateContextName(
true,
table.TableName,
table.OptionalContextName,
statementSpec.Raw.OptionalContextName,
false);
var filter =
ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(tableStreamSpec.FilterExpressions);
viewableActivatorForges[stream] = new ViewableActivatorTableForge(table, filter);
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
eventTypeNames[stream] = tableStreamSpec.Table.TableName;
streamEventTypes[stream] = tableStreamSpec.Table.InternalEventType;
joinAnalysisResult.SetTablesForStream(stream, table);
if (tableStreamSpec.Options.IsUnidirectional) {
throw new ExprValidationException("Tables cannot be marked as unidirectional");
}
if (tableStreamSpec.Options.IsRetainIntersection || tableStreamSpec.Options.IsRetainUnion) {
throw new ExprValidationException("Tables cannot be marked with retain");
}
}
else if (streamSpec is DBStatementStreamSpec) {
ValidateNoViews(streamSpec, "Historical data");
var sqlStreamSpec = (DBStatementStreamSpec) streamSpec;
var typeConversionHook = (SQLColumnTypeConversion) ImportUtil.GetAnnotationHook(
statementSpec.Annotations,
HookType.SQLCOL,
typeof(SQLColumnTypeConversion),
services.ImportServiceCompileTime);
var outputRowConversionHook = (SQLOutputRowConversion) ImportUtil.GetAnnotationHook(
statementSpec.Annotations,
HookType.SQLROW,
typeof(SQLOutputRowConversion),
services.ImportServiceCompileTime);
var viewable = HistoricalEventViewableDatabaseForgeFactory.CreateDBStatementView(
stream,
sqlStreamSpec,
typeConversionHook,
outputRowConversionHook,
@base,
services,
statementSpec.Annotations);
streamEventTypes[stream] = viewable.EventType;
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
viewableActivatorForges[stream] = new ViewableActivatorHistoricalForge(viewable);
historicalEventViewables[stream] = viewable;
}
else if (streamSpec is MethodStreamSpec) {
ValidateNoViews(streamSpec, "Method data");
var methodStreamSpec = (MethodStreamSpec) streamSpec;
var viewable = HistoricalEventViewableMethodForgeFactory.CreateMethodStatementView(
stream,
methodStreamSpec,
@base,
services);
historicalEventViewables[stream] = viewable;
streamEventTypes[stream] = viewable.EventType;
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
viewableActivatorForges[stream] = new ViewableActivatorHistoricalForge(viewable);
historicalEventViewables[stream] = viewable;
}
else {
throw new IllegalStateException("Unrecognized stream " + streamSpec);
}
// plan serde for iterate-unbound
if (isCanIterateUnbound) {
var serdeForgeables = SerdeEventTypeUtility.Plan(
streamEventTypes[stream], @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
// handle match-recognize pattern
if (statementSpec.Raw.MatchRecognizeSpec != null) {
if (numStreams > 1) {
throw new ExprValidationException("Joins are not allowed when using match-recognize");
}
if (joinAnalysisResult.TablesPerStream[0] != null) {
throw new ExprValidationException("Tables cannot be used with match-recognize");
}
var isUnbound = viewForges[0].IsEmpty() &&
!(statementSpec.StreamSpecs[0] is NamedWindowConsumerStreamSpec);
var eventType = viewForges[0].IsEmpty()
? streamEventTypes[0]
: viewForges[0][(viewForges[0].Count - 1)].EventType;
var plan = RowRecogNFAViewPlanUtil.ValidateAndPlan(services.Container, eventType, isUnbound, @base, services);
var forge = new RowRecogNFAViewFactoryForge(plan.Forge);
additionalForgeables.AddAll(plan.AdditionalForgeables);
scheduleHandleCallbackProviders.Add(forge);
viewForges[0].Add(forge);
var serdeForgeables = SerdeEventTypeUtility.Plan(
eventType, @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
// Obtain event types from view factory chains
for (var i = 0; i < viewForges.Length; i++) {
streamEventTypes[i] = viewForges[i].IsEmpty()
? streamEventTypes[i]
: viewForges[i][(viewForges[i].Count - 1)].EventType;
}
// add unique-information to join analysis
joinAnalysisResult.AddUniquenessInfo(viewForges, statementSpec.Annotations);
// plan sub-selects
SubSelectHelperForgePlan subselectForgePlan = SubSelectHelperForgePlanner.PlanSubSelect(
@base, subselectActivation, streamNames, streamEventTypes, eventTypeNames, services);
var subselectForges = subselectForgePlan.Subselects;
additionalForgeables.AddAll(subselectForgePlan.AdditionalForgeables);
DetermineViewSchedules(subselectForges, scheduleHandleCallbackProviders);
// determine view schedules
var viewResourceDelegateExpr = new ViewResourceDelegateExpr();
ViewFactoryForgeUtil.DetermineViewSchedules(viewForges, scheduleHandleCallbackProviders);
var hasIStreamOnly = StatementForgeMethodSelectUtil.GetHasIStreamOnly(isNamedWindow, viewForges);
var optionalStreamsIfAny = OuterJoinAnalyzer.OptionalStreamsIfAny(statementSpec.Raw.OuterJoinDescList);
StreamTypeService typeService = new StreamTypeServiceImpl(
streamEventTypes,
streamNames,
hasIStreamOnly,
false,
optionalStreamsIfAny);
// Validate views that require validation, specifically streams that don't have
// sub-views such as DB SQL joins
var historicalViewableDesc = new HistoricalViewableDesc(numStreams);
for (var stream = 0; stream < historicalEventViewables.Length; stream++) {
var historicalEventViewable = historicalEventViewables[stream];
if (historicalEventViewable == null) {
continue;
}
scheduleHandleCallbackProviders.Add(historicalEventViewable);
IList<StmtClassForgeableFactory> forgeables = historicalEventViewable.Validate(typeService, @base, services);
additionalForgeables.AddAll(forgeables);
historicalViewableDesc.SetHistorical(stream, historicalEventViewable.RequiredStreams);
if (historicalEventViewable.RequiredStreams.Contains(stream)) {
throw new ExprValidationException(
"Parameters for historical stream " +
stream +
" indicate that the stream is subordinate to itself as stream parameters originate in the same stream");
}
}
// Validate where-clause filter tree, outer join clause and output limit expression
var whereClauseValidated = EPStatementStartMethodHelperValidate.ValidateNodes(
statementSpec.Raw,
typeService,
viewResourceDelegateExpr,
@base.StatementRawInfo,
services);
var whereClauseForge = whereClauseValidated?.Forge;
// Obtain result set processor
var resultSetProcessorDesc = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(statementSpec),
typeService,
viewResourceDelegateExpr,
joinAnalysisResult.UnidirectionalInd,
true,
@base.ContextPropertyRegistry,
false,
false,
@base.StatementRawInfo,
services);
additionalForgeables.AddAll(resultSetProcessorDesc.AdditionalForgeables);
// Handle 'prior' function nodes in terms of view requirements
var viewResourceDelegateDesc =
ViewResourceVerifyHelper.VerifyPreviousAndPriorRequirements(viewForges, viewResourceDelegateExpr);
var hasPrior = ViewResourceDelegateDesc.HasPrior(viewResourceDelegateDesc);
if (hasPrior) {
for (var stream = 0; stream < numStreams; stream++) {
if (!viewResourceDelegateDesc[stream].PriorRequests.IsEmpty()) {
viewForges[stream].Add(new PriorEventViewForge(viewForges[stream].IsEmpty(), streamEventTypes[stream]));
var serdeForgeables = SerdeEventTypeUtility.Plan(
streamEventTypes[stream], @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
}
var outputProcessDesc = OutputProcessViewForgeFactory.Make(
typeService.EventTypes,
resultSetProcessorDesc.ResultEventType,
resultSetProcessorDesc.ResultSetProcessorType,
statementSpec,
@base.StatementRawInfo,
services);
var outputProcessViewFactoryForge = outputProcessDesc.Forge;
additionalForgeables.AddAll(outputProcessDesc.AdditionalForgeables);
outputProcessViewFactoryForge.CollectSchedules(scheduleHandleCallbackProviders);
JoinSetComposerPrototypeForge joinForge = null;
if (numStreams > 1) {
var hasAggregations = !resultSetProcessorDesc.AggregationServiceForgeDesc.Expressions.IsEmpty();
var desc = JoinSetComposerPrototypeForgeFactory.MakeComposerPrototype(
statementSpec,
joinAnalysisResult,
typeService,
historicalViewableDesc,
false,
hasAggregations,
@base.StatementRawInfo,
services);
joinForge = desc.Forge;
additionalForgeables.AddAll(desc.AdditionalForgeables);
HandleIndexDependencies(joinForge.OptionalQueryPlan, services);
}
// plan table access
var tableAccessForges =
ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes);
ValidateTableAccessUse(statementSpec.Raw.IntoTableSpec, statementSpec.Raw.TableExpressions);
if (joinAnalysisResult.IsUnidirectional && statementSpec.Raw.IntoTableSpec != null) {
throw new ExprValidationException("Into-table does not allow unidirectional joins");
}
var orderByWithoutOutputLimit = statementSpec.Raw.OrderByList != null &&
!statementSpec.Raw.OrderByList.IsEmpty() &&
statementSpec.Raw.OutputLimitSpec == null;
var statementAIFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var resultSetProcessorProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
var outputProcessViewProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(OutputProcessViewFactoryProvider),
classPostfix);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
//var statementFieldsClassName = namespaceScope.FieldsClassNameOptional;
var forgeX = new StatementAgentInstanceFactorySelectForge(
typeService.StreamNames,
viewableActivatorForges,
resultSetProcessorProviderClassName,
viewForges,
viewResourceDelegateDesc,
whereClauseForge,
joinForge,
outputProcessViewProviderClassName,
subselectForges,
tableAccessForges,
orderByWithoutOutputLimit,
joinAnalysisResult.IsUnidirectional);
var namespaceScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var forgeablesX = additionalForgeables
.Select(additional => additional.Make(namespaceScope, classPostfix))
.ToList();
forgeablesX.Add(
new StmtClassForgeableRSPFactoryProvider(
resultSetProcessorProviderClassName,
resultSetProcessorDesc,
namespaceScope,
@base.StatementRawInfo));
forgeablesX.Add(
new StmtClassForgeableOPVFactoryProvider(
outputProcessViewProviderClassName,
outputProcessViewFactoryForge,
namespaceScope,
numStreams,
@base.StatementRawInfo));
forgeablesX.Add(
new StmtClassForgeableAIFactoryProviderSelect(statementAIFactoryProviderClassName, namespaceScope, forgeX));
forgeablesX.Add(
new StmtClassForgeableStmtFields(statementFieldsClassName, namespaceScope, numStreams));
if (!dataflowOperator) {
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
filterSpecCompileds,
scheduleHandleCallbackProviders,
namedWindowConsumers,
true,
resultSetProcessorDesc.SelectSubscriberDescriptor,
namespaceScope,
services);
forgeablesX.Add(
new StmtClassForgeableStmtProvider(statementAIFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope));
}
var forgeableResult = new StmtForgeMethodResult(
forgeablesX,
filterSpecCompileds,
scheduleHandleCallbackProviders,
namedWindowConsumers,
FilterSpecCompiled.MakeExprNodeList(filterSpecCompileds, EmptyList<FilterSpecParamExprNodeForge>.Instance));
return new StmtForgeMethodSelectResult(forgeableResult, resultSetProcessorDesc.ResultEventType, numStreams);
}
public FAFQueryMethodIUDBaseForge(
StatementSpecCompiled spec,
Compilable compilable,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
this.annotations = spec.Annotations;
this.hasTableAccess = spec.Raw.IntoTableSpec != null ||
(spec.TableAccessNodes != null && spec.TableAccessNodes.Count > 0);
if (spec.Raw.InsertIntoDesc != null &&
services.TableCompileTimeResolver.Resolve(spec.Raw.InsertIntoDesc.EventTypeName) != null) {
hasTableAccess = true;
}
if (spec.Raw.FireAndForgetSpec is FireAndForgetSpecUpdate ||
spec.Raw.FireAndForgetSpec is FireAndForgetSpecDelete) {
hasTableAccess |= spec.StreamSpecs[0] is TableQueryStreamSpec;
}
hasTableAccess |= StatementLifecycleSvcUtil.IsSubqueryWithTable(
spec.SubselectNodes, services.TableCompileTimeResolver);
// validate general FAF criteria
FAFQueryMethodHelper.ValidateFAFQuery(spec);
// obtain processor
StreamSpecCompiled streamSpec = spec.StreamSpecs[0];
processor = FireAndForgetProcessorForgeFactory.ValidateResolveProcessor(streamSpec);
// obtain name and type
string processorName = processor.NamedWindowOrTableName;
EventType eventType = processor.EventTypeRspInputEvents;
// determine alias
string aliasName = processorName;
if (streamSpec.OptionalStreamName != null) {
aliasName = streamSpec.OptionalStreamName;
}
// activate subselect activations
var @base = new StatementBaseInfo(compilable, spec, null, statementRawInfo, null);
var subqueryNamedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
var subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation(
EmptyList<FilterSpecCompiled>.Instance, subqueryNamedWindowConsumers, @base, services);
var subselectActivation = subSelectActivationDesc.Subselects;
_additionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables);
// plan subselects
var namesPerStream = new[] {aliasName};
var typesPerStream = new[] { processor.EventTypePublic };
var eventTypeNames = new[] {typesPerStream[0].Name};
SubSelectHelperForgePlan subSelectForgePlan = SubSelectHelperForgePlanner.PlanSubSelect(
@base, subselectActivation, namesPerStream, typesPerStream, eventTypeNames, services);
_subselectForges = subSelectForgePlan.Subselects;
_additionalForgeables.AddAll(subSelectForgePlan.AdditionalForgeables);
// compile filter to optimize access to named window
StreamTypeServiceImpl typeService = new StreamTypeServiceImpl(
new[] {eventType},
new[] {aliasName},
new[] {true},
true,
false);
ExcludePlanHint excludePlanHint = ExcludePlanHint.GetHint(
typeService.StreamNames,
statementRawInfo,
services);
if (spec.Raw.WhereClause != null) {
queryGraph = new QueryGraphForge(1, excludePlanHint, false);
EPLValidationUtil.ValidateFilterWQueryGraphSafe(
queryGraph,
spec.Raw.WhereClause,
typeService,
statementRawInfo,
services);
}
else {
queryGraph = null;
}
// validate expressions
whereClause = EPStatementStartMethodHelperValidate.ValidateNodes(
spec.Raw,
typeService,
null,
statementRawInfo,
services);
// get executor
InitExec(aliasName, spec, statementRawInfo, services);
// plan table access
tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(spec.Raw.TableExpressions);
}
public FAFQueryMethodSelectDesc(
StatementSpecCompiled statementSpec,
Compilable compilable,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
Annotations = statementSpec.Annotations;
ContextName = statementSpec.Raw.OptionalContextName;
var queryPlanLogging = services.Configuration.Common.Logging.IsEnableQueryPlan;
if (queryPlanLogging) {
QUERY_PLAN_LOG.Info("Query plans for Fire-and-forget query '" + compilable.ToEPL() + "'");
}
HasTableAccess = statementSpec.TableAccessNodes != null && statementSpec.TableAccessNodes.Count > 0;
foreach (var streamSpec in statementSpec.StreamSpecs) {
HasTableAccess |= streamSpec is TableQueryStreamSpec;
}
HasTableAccess |= StatementLifecycleSvcUtil.IsSubqueryWithTable(
statementSpec.SubselectNodes, services.TableCompileTimeResolver);
IsDistinct = statementSpec.SelectClauseCompiled.IsDistinct;
FAFQueryMethodHelper.ValidateFAFQuery(statementSpec);
var numStreams = statementSpec.StreamSpecs.Length;
var typesPerStream = new EventType[numStreams];
var namesPerStream = new string[numStreams];
var eventTypeNames = new string[numStreams];
Processors = new FireAndForgetProcessorForge[numStreams];
ConsumerFilters = new ExprNode[numStreams];
// check context partition use
if (statementSpec.Raw.OptionalContextName != null) {
if (numStreams > 1) {
throw new ExprValidationException(
"Joins in runtime queries for context partitions are not supported");
}
}
// resolve types and processors
for (var i = 0; i < numStreams; i++) {
var streamSpec = statementSpec.StreamSpecs[i];
Processors[i] = FireAndForgetProcessorForgeFactory.ValidateResolveProcessor(streamSpec);
if (numStreams > 1 && Processors[i].ContextName != null) {
throw new ExprValidationException(
"Joins against named windows that are under context are not supported");
}
var streamName = Processors[i].NamedWindowOrTableName;
if (streamSpec.OptionalStreamName != null) {
streamName = streamSpec.OptionalStreamName;
}
namesPerStream[i] = streamName;
typesPerStream[i] = Processors[i].EventTypeRspInputEvents;
eventTypeNames[i] = typesPerStream[i].Name;
IList<ExprNode> consumerFilterExprs;
if (streamSpec is NamedWindowConsumerStreamSpec) {
var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec;
consumerFilterExprs = namedSpec.FilterExpressions;
}
else {
var tableSpec = (TableQueryStreamSpec) streamSpec;
consumerFilterExprs = tableSpec.FilterExpressions;
}
ConsumerFilters[i] = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(consumerFilterExprs);
}
// compile filter to optimize access to named window
var optionalStreamsIfAny = OuterJoinAnalyzer.OptionalStreamsIfAny(statementSpec.Raw.OuterJoinDescList);
var types = new StreamTypeServiceImpl(
typesPerStream,
namesPerStream,
new bool[numStreams],
false,
optionalStreamsIfAny);
var excludePlanHint = ExcludePlanHint.GetHint(types.StreamNames, statementRawInfo, services);
QueryGraph = new QueryGraphForge(numStreams, excludePlanHint, false);
if (statementSpec.Raw.WhereClause != null) {
for (var i = 0; i < numStreams; i++) {
try {
var validationContext = new ExprValidationContextBuilder(types, statementRawInfo, services)
.WithAllowBindingConsumption(true)
.WithIsFilterExpression(true)
.Build();
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.FILTER,
statementSpec.Raw.WhereClause,
validationContext);
FilterExprAnalyzer.Analyze(validated, QueryGraph, false);
}
catch (Exception ex) {
Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex);
}
}
}
// handle subselects
// first we create streams for subselects, if there are any
var @base = new StatementBaseInfo(compilable, statementSpec, null, statementRawInfo, null);
var subqueryNamedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
SubSelectActivationDesc subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation(
EmptyList<FilterSpecCompiled>.Instance, subqueryNamedWindowConsumers, @base, services);
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation = subSelectActivationDesc.Subselects;
AdditionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables);
SubSelectHelperForgePlan subSelectForgePlan = SubSelectHelperForgePlanner.PlanSubSelect(
@base, subselectActivation, namesPerStream, typesPerStream, eventTypeNames, services);
SubselectForges = subSelectForgePlan.Subselects;
AdditionalForgeables.AddAll(subSelectForgePlan.AdditionalForgeables);
// obtain result set processor
var isIStreamOnly = new bool[namesPerStream.Length];
isIStreamOnly.Fill(true);
StreamTypeService typeService = new StreamTypeServiceImpl(
typesPerStream,
namesPerStream,
isIStreamOnly,
true,
optionalStreamsIfAny);
WhereClause = EPStatementStartMethodHelperValidate.ValidateNodes(
statementSpec.Raw,
typeService,
null,
statementRawInfo,
services);
var resultSetSpec = new ResultSetSpec(statementSpec);
ResultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
resultSetSpec,
typeService,
null,
new bool[0],
true,
null,
true,
false,
statementRawInfo,
services);
AdditionalForgeables.AddAll(ResultSetProcessor.AdditionalForgeables);
// plan table access
TableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(statementSpec.Raw.TableExpressions);
// plan joins or simple queries
if (numStreams > 1) {
var streamJoinAnalysisResult = new StreamJoinAnalysisResultCompileTime(numStreams);
CompatExtensions.Fill(streamJoinAnalysisResult.NamedWindowsPerStream, (NamedWindowMetaData) null);
for (var i = 0; i < numStreams; i++) {
var uniqueIndexes = Processors[i].UniqueIndexes;
streamJoinAnalysisResult.UniqueKeys[i] = uniqueIndexes;
}
var hasAggregations = ResultSetProcessor.ResultSetProcessorType.IsAggregated();
var desc = JoinSetComposerPrototypeForgeFactory.MakeComposerPrototype(
statementSpec,
streamJoinAnalysisResult,
types,
new HistoricalViewableDesc(numStreams),
true,
hasAggregations,
statementRawInfo,
services);
AdditionalForgeables.AddAll(desc.AdditionalForgeables);
Joins = desc.Forge;
}
else {
Joins = null;
}
var multiKeyPlan = MultiKeyPlanner.PlanMultiKeyDistinct(
IsDistinct, ResultSetProcessor.ResultEventType, statementRawInfo, SerdeCompileTimeResolverNonHA.INSTANCE);
AdditionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables);
DistinctMultiKey = multiKeyPlan.ClassRef;
}
public FAFQueryMethodIUDBaseForge(
StatementSpecCompiled spec,
Compilable compilable,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
this.annotations = spec.Annotations;
this.hasTableAccess = spec.Raw.IntoTableSpec != null ||
(spec.TableAccessNodes != null && spec.TableAccessNodes.Count > 0);
if (spec.Raw.InsertIntoDesc != null &&
services.TableCompileTimeResolver.Resolve(spec.Raw.InsertIntoDesc.EventTypeName) != null) {
hasTableAccess = true;
}
if (spec.Raw.FireAndForgetSpec is FireAndForgetSpecUpdate ||
spec.Raw.FireAndForgetSpec is FireAndForgetSpecDelete) {
hasTableAccess |= spec.StreamSpecs[0] is TableQueryStreamSpec;
}
// validate general FAF criteria
FAFQueryMethodHelper.ValidateFAFQuery(spec);
// obtain processor
StreamSpecCompiled streamSpec = spec.StreamSpecs[0];
processor = FireAndForgetProcessorForgeFactory.ValidateResolveProcessor(streamSpec);
// obtain name and type
string processorName = processor.NamedWindowOrTableName;
EventType eventType = processor.EventTypeRspInputEvents;
// determine alias
string aliasName = processorName;
if (streamSpec.OptionalStreamName != null) {
aliasName = streamSpec.OptionalStreamName;
}
// compile filter to optimize access to named window
StreamTypeServiceImpl typeService = new StreamTypeServiceImpl(
new EventType[] {eventType},
new string[] {aliasName},
new bool[] {true},
true,
false);
ExcludePlanHint excludePlanHint = ExcludePlanHint.GetHint(
typeService.StreamNames,
statementRawInfo,
services);
if (spec.Raw.WhereClause != null) {
queryGraph = new QueryGraphForge(1, excludePlanHint, false);
EPLValidationUtil.ValidateFilterWQueryGraphSafe(
queryGraph,
spec.Raw.WhereClause,
typeService,
statementRawInfo,
services);
}
else {
queryGraph = null;
}
// validate expressions
whereClause = EPStatementStartMethodHelperValidate.ValidateNodes(
spec.Raw,
typeService,
null,
statementRawInfo,
services);
// get executor
InitExec(aliasName, spec, statementRawInfo, services);
// plan table access
tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(spec.Raw.TableExpressions);
}
