public AIRegistryAggregation AllocateSubselectAggregation(ExprSubselectNode subselectNode)
{
AIRegistryAggregation subselectAggregation = AllocateAIRegistrySubselectAggregation();
_subselectAggregations.Put(subselectNode, subselectAggregation);
return(subselectAggregation);
}
public AIRegistrySubselect AllocateSubselect(ExprSubselectNode subselectNode)
{
AIRegistrySubselect subselect = AllocateAIRegistrySubselect();
_subselects.Put(subselectNode, subselect);
return(subselect);
}
/// <summary>
/// Add lookup.
/// </summary>
/// <param name="subselectNode">is the subselect expression node</param>
/// <param name="prototypeHolder">The Prototype holder.</param>
public void Add(ExprSubselectNode subselectNode, SubSelectStrategyFactoryDesc prototypeHolder)
{
if (_subqueries == null)
{
_subqueries = new Dictionary <ExprSubselectNode, SubSelectStrategyFactoryDesc>();
}
_subqueries.Put(subselectNode, prototypeHolder);
}
public AIRegistryAggregation GetOrAllocateSubselectAggregation(ExprSubselectNode subselectNode)
{
AIRegistryAggregation existing = _subselectAggregations.Get(subselectNode);
if (existing != null)
{
return(existing);
}
return(AllocateSubselectAggregation(subselectNode));
}
public AIRegistrySubselect GetOrAllocateSubquery(ExprSubselectNode key)
{
AIRegistrySubselect existing = _subselects.Get(key);
if (existing != null)
{
return(existing);
}
return(AllocateSubselect(key));
}
public static string GetSubqueryInfoText(ExprSubselectNode subselect)
{
string text = "subquery number " + (subselect.SubselectNumber + 1);
StreamSpecRaw streamRaw = subselect.StatementSpecRaw.StreamSpecs[0];
if (streamRaw is FilterStreamSpecRaw) {
text += " querying " + ((FilterStreamSpecRaw) streamRaw).RawFilterSpec.EventTypeName;
}
return text;
}
public void QExprSubselect(ExprSubselectNode exprSubselectNode)
{
}
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");
}
}
}
}
}
}
/// <summary>Returns the lookup's view factory chain. </summary>
/// <param name="subqueryNode">is the node to look for</param>
/// <returns>view factory chain</returns>
public ViewFactoryChain GetViewFactoryChain(ExprSubselectNode subqueryNode)
{
return(_subqueries.Get(subqueryNode).ViewFactoryChain);
}
public void QFilterActivationSubselect(string eventTypeName, ExprSubselectNode subselectNode)
{
}
/// <summary>Returns stream number. </summary>
/// <param name="subqueryNode">is the lookup node's stream number</param>
/// <returns>number of stream</returns>
public int GetStreamNumber(ExprSubselectNode subqueryNode)
{
return(_subqueries.Get(subqueryNode).StreamNumber);
}
/// <summary>Returns the lookup viewable, child-most view. </summary>
/// <param name="subqueryNode">is the expression node to get this for</param>
/// <returns>child viewable</returns>
public EventType GetRootViewableType(ExprSubselectNode subqueryNode)
{
return(_subqueries.Get(subqueryNode).ViewableType);
}
/// <summary>
/// Gets the sub select holder.
/// </summary>
/// <param name="subselectNode">The subselect node.</param>
/// <returns></returns>
public SubSelectActivationHolder GetSubSelectHolder(ExprSubselectNode subselectNode)
{
return(_subqueries.Get(subselectNode));
}
/// <summary>
/// Add lookup.
/// </summary>
/// <param name="subselectNode">is the subselect expression node</param>
/// <param name="holder">The holder.</param>
public void Add(ExprSubselectNode subselectNode, SubSelectActivationHolder holder)
{
_subqueries.Put(subselectNode, holder);
}
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);
}
public AIRegistrySubselect GetSubselectService(ExprSubselectNode exprSubselectNode)
{
return(_subselects.Get(exprSubselectNode));
}
public AIRegistryAggregation GetSubselectAggregationService(ExprSubselectNode exprSubselectNode)
{
return(_subselectAggregations.Get(exprSubselectNode));
}
