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;
}