public QueryGraph GetLogicQueryGraph()
{
QueryGraph qg = new QueryGraph();
//create nodes
foreach (ViewerQueryNode vqn in m_ViewerQueryGraph.NodesList)
{
ISubgraphMatchCell c = vqn.ToCell();
qg.AddCell(c);
m_Viewer2LogicDic.Add(vqn.ID, c.CellID);
m_Logic2ViewerDic.Add(c.CellID, vqn.ID);
}
//create edges
foreach (ViewerQueryNode vqn in m_ViewerQueryGraph.NodesList)
{
ISubgraphMatchCell c1 = qg.LoadCell(m_Viewer2LogicDic[vqn.ID]);
foreach (int id in vqn.OutLinkList)
{
ISubgraphMatchCell c2 = qg.LoadCell(m_Viewer2LogicDic[id]);
c1.TargetCellSet.Add(c2.CellID);
c2.SourceCellSet.Add(c1.CellID);
}
}
return qg;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="statementSpec">
/// is a container for the definition of all statement constructs that may have been used in the
/// statement, i.e. if defines the select clauses, insert into, outer joins etc.
/// </param>
/// <param name="services">is the service instances for dependency injection</param>
/// <param name="statementContext">is statement-level information and statement services</param>
/// <throws>ExprValidationException if the preparation failed</throws>
public EPPreparedExecuteMethodQuery(
StatementSpecCompiled statementSpec,
EPServicesContext services,
StatementContext statementContext)
{
var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.Logging.IsEnableQueryPlan;
if (queryPlanLogging)
{
QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'");
}
_hasTableAccess = (statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0);
foreach (var streamSpec in statementSpec.StreamSpecs)
{
_hasTableAccess |= streamSpec is TableQueryStreamSpec;
}
_statementSpec = statementSpec;
_services = services;
EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec);
var numStreams = statementSpec.StreamSpecs.Length;
var typesPerStream = new EventType[numStreams];
var namesPerStream = new string[numStreams];
_processors = new FireAndForgetProcessor[numStreams];
_agentInstanceContext = new AgentInstanceContext(statementContext, null, -1, null, null, statementContext.DefaultAgentInstanceScriptContext);
// resolve types and processors
for (var i = 0; i < numStreams; i++)
{
var streamSpec = statementSpec.StreamSpecs[i];
_processors[i] = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services);
string streamName = _processors[i].NamedWindowOrTableName;
if (streamSpec.OptionalStreamName != null)
{
streamName = streamSpec.OptionalStreamName;
}
namesPerStream[i] = streamName;
typesPerStream[i] = _processors[i].EventTypeResultSetProcessor;
}
// compile filter to optimize access to named window
var types = new StreamTypeServiceImpl(typesPerStream, namesPerStream, new bool[numStreams], services.EngineURI, false);
var excludePlanHint = ExcludePlanHint.GetHint(types.StreamNames, statementContext);
_queryGraph = new QueryGraph(numStreams, excludePlanHint, false);
if (statementSpec.FilterRootNode != null)
{
for (var i = 0; i < numStreams; i++)
{
try
{
ExprEvaluatorContextStatement evaluatorContextStmt = new ExprEvaluatorContextStatement(statementContext, false);
ExprValidationContext validationContext = new ExprValidationContext(
statementContext.Container,
types,
statementContext.EngineImportService,
statementContext.StatementExtensionServicesContext, null,
statementContext.TimeProvider,
statementContext.VariableService,
statementContext.TableService, evaluatorContextStmt,
statementContext.EventAdapterService,
statementContext.StatementName,
statementContext.StatementId,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ScriptingService,
false, false, true, false, null, true);
ExprNode validated = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.FILTER, statementSpec.FilterRootNode, validationContext);
FilterExprAnalyzer.Analyze(validated, _queryGraph, false);
}
catch (Exception ex)
{
Log.Warn("Unexpected exception analyzing filter paths: " + ex.Message, ex);
}
}
}
// obtain result set processor
var isIStreamOnly = new bool[namesPerStream.Length];
CompatExtensions.Fill(isIStreamOnly, true);
StreamTypeService typeService = new StreamTypeServiceImpl(typesPerStream, namesPerStream, isIStreamOnly, services.EngineURI, true);
EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null);
var resultSetProcessorPrototype = ResultSetProcessorFactoryFactory.GetProcessorPrototype(statementSpec, statementContext, typeService, null, new bool[0], true, ContextPropertyRegistryImpl.EMPTY_REGISTRY, null, services.ConfigSnapshot, services.ResultSetProcessorHelperFactory, true, false);
_resultSetProcessor = EPStatementStartMethodHelperAssignExpr.GetAssignResultSetProcessor(_agentInstanceContext, resultSetProcessorPrototype, false, null, true);
if (statementSpec.SelectClauseSpec.IsDistinct)
{
if (_resultSetProcessor.ResultEventType is EventTypeSPI)
{
_eventBeanReader = ((EventTypeSPI)_resultSetProcessor.ResultEventType).Reader;
}
if (_eventBeanReader == null)
{
_eventBeanReader = new EventBeanReaderDefaultImpl(_resultSetProcessor.ResultEventType);
}
}
// check context partition use
if (statementSpec.OptionalContextName != null)
{
if (numStreams > 1)
{
throw new ExprValidationException("Joins in runtime queries for context partitions are not supported");
}
}
// plan joins or simple queries
if (numStreams > 1)
{
var streamJoinAnalysisResult = new StreamJoinAnalysisResult(numStreams);
CompatExtensions.Fill(streamJoinAnalysisResult.NamedWindow, true);
for (var i = 0; i < numStreams; i++)
{
var processorInstance = _processors[i].GetProcessorInstance(_agentInstanceContext);
if (_processors[i].IsVirtualDataWindow)
{
streamJoinAnalysisResult.ViewExternal[i] = agentInstanceContext => processorInstance.VirtualDataWindow;
}
var uniqueIndexes = _processors[i].GetUniqueIndexes(processorInstance);
streamJoinAnalysisResult.UniqueKeys[i] = uniqueIndexes;
}
var hasAggregations = !resultSetProcessorPrototype.AggregationServiceFactoryDesc.Expressions.IsEmpty();
_joinSetComposerPrototype = JoinSetComposerPrototypeFactory.MakeComposerPrototype(null, -1,
statementSpec.OuterJoinDescList, statementSpec.FilterRootNode, typesPerStream, namesPerStream,
streamJoinAnalysisResult, queryPlanLogging, statementContext, new HistoricalViewableDesc(numStreams),
_agentInstanceContext, false, hasAggregations, services.TableService, true,
services.EventTableIndexService.AllowInitIndex(false));
}
}
public override ICollection <EventBean> SnapshotBestEffort(EPPreparedExecuteMethodQuery query, QueryGraph queryGraph, Attribute[] annotations)
{
EPPreparedExecuteTableHelper.AssignTableAccessStrategies(query.Services, query.TableNodes, _processorInstance.TailViewInstance.AgentInstanceContext);
return(_processorInstance.TailViewInstance.Snapshot(queryGraph, annotations));
}
public void Apply(QueryGraph queryGraph)
{
ExprIdentNode targetExpr = ExprNodeUtility.GetExprIdentNode(typesPerStream, targetStreamNum, targetPropertyName);
RangeFilterAnalyzer.Apply(targetExpr, start, end, includeLow, includeHigh, false, queryGraph);
}
public ICollection<EventBean> Snapshot(
QueryGraph queryGraph,
Attribute[] annotations)
=> ProcSnapshot(queryGraph, annotations);
public abstract EPPreparedExecuteIUDSingleStreamExec GetExecutor(QueryGraph queryGraph, string aliasName);
/// <summary>
/// Ctor.
/// </summary>
/// <param name="statementSpec">is a container for the definition of all statement constructs thatmay have been used in the statement, i.e. if defines the select clauses, insert into, outer joins etc.
/// </param>
/// <param name="services">is the service instances for dependency injection</param>
/// <param name="statementContext">is statement-level information and statement services</param>
/// <throws>com.espertech.esper.epl.expression.core.ExprValidationException if the preparation failed</throws>
public EPPreparedExecuteIUDSingleStream(
StatementSpecCompiled statementSpec,
EPServicesContext services,
StatementContext statementContext)
{
var queryPlanLogging = services.ConfigSnapshot.EngineDefaults.Logging.IsEnableQueryPlan;
if (queryPlanLogging)
{
QueryPlanLog.Info("Query plans for Fire-and-forget query '" + statementContext.Expression + "'");
}
HasTableAccess = statementSpec.IntoTableSpec != null ||
(statementSpec.TableNodes != null && statementSpec.TableNodes.Length > 0);
if (statementSpec.InsertIntoDesc != null && services.TableService.GetTableMetadata(statementSpec.InsertIntoDesc.EventTypeName) != null)
{
HasTableAccess = true;
}
if (statementSpec.FireAndForgetSpec is FireAndForgetSpecUpdate ||
statementSpec.FireAndForgetSpec is FireAndForgetSpecDelete)
{
HasTableAccess |= statementSpec.StreamSpecs[0] is TableQueryStreamSpec;
}
StatementSpec = statementSpec;
Services = services;
StatementContext = statementContext;
// validate general FAF criteria
EPPreparedExecuteMethodHelper.ValidateFAFQuery(statementSpec);
// obtain processor
var streamSpec = statementSpec.StreamSpecs[0];
Processor = FireAndForgetProcessorFactory.ValidateResolveProcessor(streamSpec, services);
// obtain name and type
var processorName = Processor.NamedWindowOrTableName;
var eventType = Processor.EventTypeResultSetProcessor;
// determine alias
var aliasName = processorName;
if (streamSpec.OptionalStreamName != null)
{
aliasName = streamSpec.OptionalStreamName;
}
// compile filter to optimize access to named window
var typeService = new StreamTypeServiceImpl(new EventType[] { eventType }, new string[] { aliasName }, new bool[] { true }, services.EngineURI, true);
var excludePlanHint = ExcludePlanHint.GetHint(typeService.StreamNames, statementContext);
var queryGraph = new QueryGraph(1, excludePlanHint, false);
if (statementSpec.FilterRootNode != null)
{
ExprNodeUtility.ValidateFilterWQueryGraphSafe(
queryGraph, statementSpec.FilterRootNode,
statementContext, typeService);
}
// validate expressions
EPStatementStartMethodHelperValidate.ValidateNodes(statementSpec, statementContext, typeService, null);
// get executor
Executor = GetExecutor(queryGraph, aliasName);
}
public TestSchema()
{
Query = new QueryGraph();
}
public WikidataEndpointQueryRunner(QueryGraph graph)
{
//graph.ResetTraverse();
QueryGraph = graph;
}
public abstract ICollection <EventBean> SnapshotBestEffort(EPPreparedExecuteMethodQuery epPreparedExecuteMethodQuery, QueryGraph queryGraph, Attribute[] annotations);
public override EPPreparedExecuteIUDSingleStreamExec GetExecutor(QueryGraph queryGraph, string aliasName)
{
var statementSpec = base.StatementSpec;
var statementContext = base.StatementContext;
var selectNoWildcard = NamedWindowOnMergeHelper.CompileSelectNoWildcard(UuidGenerator.Generate(), statementSpec.SelectClauseSpec.SelectExprList);
var streamTypeService = new StreamTypeServiceImpl(statementContext.EngineURI, true);
var exprEvaluatorContextStatement = new ExprEvaluatorContextStatement(statementContext, true);
// assign names
var validationContext = new ExprValidationContext(
statementContext.Container,
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);
var processor = base.Processor;
// 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;
var 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;
}
}
}
}
var optionalInsertIntoEventType = processor.EventTypeResultSetProcessor;
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry(statementContext.StatementName, statementContext.StatementEventTypeRef);
var insertHelper = SelectExprProcessorFactory.GetProcessor(
statementContext.Container,
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, base.Services));
}
public void Apply(QueryGraph queryGraph)
{
if (_targetStreamNum == _parameterStreamNum)
{
return;
}
ExprIdentNode targetStartExpr = ExprNodeUtility.GetExprIdentNode(
_typesPerStream, _targetStreamNum, _targetStartProp);
ExprIdentNode targetEndExpr = ExprNodeUtility.GetExprIdentNode(
_typesPerStream, _targetStreamNum, _targetEndProp);
ExprIdentNode parameterStartExpr = ExprNodeUtility.GetExprIdentNode(
_typesPerStream, _parameterStreamNum, _parameterStartProp);
ExprIdentNode parameterEndExpr = ExprNodeUtility.GetExprIdentNode(
_typesPerStream, _parameterStreamNum, _parameterEndProp);
if (targetStartExpr.ExprEvaluator.ReturnType != parameterStartExpr.ExprEvaluator.ReturnType)
{
return;
}
if (_currentMethod == DatetimeMethodEnum.BEFORE)
{
// a.end < b.start
queryGraph.AddRelationalOpStrict(
_targetStreamNum, targetEndExpr,
_parameterStreamNum, parameterStartExpr,
RelationalOpEnum.LT);
}
else if (_currentMethod == DatetimeMethodEnum.AFTER)
{
// a.start > b.end
queryGraph.AddRelationalOpStrict(
_targetStreamNum, targetStartExpr,
_parameterStreamNum, parameterEndExpr,
RelationalOpEnum.GT);
}
else if (_currentMethod == DatetimeMethodEnum.COINCIDES)
{
// a.startTimestamp = b.startTimestamp and a.endTimestamp = b.endTimestamp
queryGraph.AddStrictEquals(_targetStreamNum, _targetStartProp, targetStartExpr,
_parameterStreamNum, _parameterStartProp, parameterStartExpr);
var noDuration = _parameterEndProp.Equals(_parameterStartProp) &&
_targetEndProp.Equals(_targetStartProp);
if (!noDuration)
{
ExprIdentNode leftEndExpr = ExprNodeUtility.GetExprIdentNode(
_typesPerStream, _targetStreamNum, _targetEndProp);
ExprIdentNode rightEndExpr = ExprNodeUtility.GetExprIdentNode(
_typesPerStream, _parameterStreamNum, _parameterEndProp);
queryGraph.AddStrictEquals(
_targetStreamNum, _targetEndProp, leftEndExpr, _parameterStreamNum, _parameterEndProp, rightEndExpr);
}
}
else if (_currentMethod == DatetimeMethodEnum.DURING || _currentMethod == DatetimeMethodEnum.INCLUDES)
{
// DURING: b.startTimestamp < a.startTimestamp <= a.endTimestamp < b.endTimestamp
// INCLUDES: a.startTimestamp < b.startTimestamp <= b.endTimestamp < a.endTimestamp
RelationalOpEnum relop = _currentMethod == DatetimeMethodEnum.DURING
? RelationalOpEnum.LT
: RelationalOpEnum.GT;
queryGraph.AddRelationalOpStrict(
_parameterStreamNum, parameterStartExpr,
_targetStreamNum, targetStartExpr, relop);
queryGraph.AddRelationalOpStrict(
_targetStreamNum, targetEndExpr,
_parameterStreamNum, parameterEndExpr, relop);
}
else if (_currentMethod == DatetimeMethodEnum.FINISHES || _currentMethod == DatetimeMethodEnum.FINISHEDBY)
{
// FINISHES: b.startTimestamp < a.startTimestamp and a.endTimestamp = b.endTimestamp
// FINISHEDBY: a.startTimestamp < b.startTimestamp and a.endTimestamp = b.endTimestamp
RelationalOpEnum relop = _currentMethod == DatetimeMethodEnum.FINISHES
? RelationalOpEnum.LT
: RelationalOpEnum.GT;
queryGraph.AddRelationalOpStrict(
_parameterStreamNum, parameterStartExpr,
_targetStreamNum, targetStartExpr, relop);
queryGraph.AddStrictEquals(
_targetStreamNum, _targetEndProp, targetEndExpr,
_parameterStreamNum, _parameterEndProp, parameterEndExpr);
}
else if (_currentMethod == DatetimeMethodEnum.MEETS)
{
// a.endTimestamp = b.startTimestamp
queryGraph.AddStrictEquals(_targetStreamNum, _targetEndProp, targetEndExpr,
_parameterStreamNum, _parameterStartProp, parameterStartExpr);
}
else if (_currentMethod == DatetimeMethodEnum.METBY)
{
// a.startTimestamp = b.endTimestamp
queryGraph.AddStrictEquals(_targetStreamNum, _targetStartProp, targetStartExpr,
_parameterStreamNum, _parameterEndProp, parameterEndExpr);
}
else if (_currentMethod == DatetimeMethodEnum.OVERLAPS || _currentMethod == DatetimeMethodEnum.OVERLAPPEDBY)
{
// OVERLAPS: a.startTimestamp < b.startTimestamp < a.endTimestamp < b.endTimestamp
// OVERLAPPEDBY: b.startTimestamp < a.startTimestamp < b.endTimestamp < a.endTimestamp
RelationalOpEnum relop = _currentMethod == DatetimeMethodEnum.OVERLAPS
? RelationalOpEnum.LT
: RelationalOpEnum.GT;
queryGraph.AddRelationalOpStrict(
_targetStreamNum, targetStartExpr,
_parameterStreamNum, parameterStartExpr, relop);
queryGraph.AddRelationalOpStrict(
_targetStreamNum, targetEndExpr,
_parameterStreamNum, parameterEndExpr, relop);
if (_currentMethod == DatetimeMethodEnum.OVERLAPS)
{
queryGraph.AddRelationalOpStrict(
_parameterStreamNum, parameterStartExpr,
_targetStreamNum, targetEndExpr, RelationalOpEnum.LT);
}
else
{
queryGraph.AddRelationalOpStrict(
_targetStreamNum, targetStartExpr,
_parameterStreamNum, parameterEndExpr, RelationalOpEnum.LT);
}
}
else if (_currentMethod == DatetimeMethodEnum.STARTS || _currentMethod == DatetimeMethodEnum.STARTEDBY)
{
// STARTS: a.startTimestamp = b.startTimestamp and a.endTimestamp < b.endTimestamp
// STARTEDBY: a.startTimestamp = b.startTimestamp and b.endTimestamp < a.endTimestamp
queryGraph.AddStrictEquals(_targetStreamNum, _targetStartProp, targetStartExpr,
_parameterStreamNum, _parameterStartProp, parameterStartExpr);
RelationalOpEnum relop = _currentMethod == DatetimeMethodEnum.STARTS
? RelationalOpEnum.LT
: RelationalOpEnum.GT;
queryGraph.AddRelationalOpStrict(
_targetStreamNum, targetEndExpr,
_parameterStreamNum, parameterEndExpr, relop);
}
}
private List<Match> SampleMatches(QueryGraph qg)
{
int matchNum = 20;
Random ra = new Random();
List<Match> res = new List<Match>();
for (int i = 0; i < matchNum; ++i)
{
Match m = new Match();
foreach (long cid in qg.CellIDSet)
{
NodePair np = new NodePair(cid, ra.Next());
m.PartialMatch.Add(np);
}
res.Add(m);
}
return res;
}
public FindFilesQuery(QueryGraph graph, EvalHandler handler)
: base(graph, handler)
{
}
