public static void AddNonAggregatedProps(
ExprNode exprNode,
ExprNodePropOrStreamSet set,
EventType[] types,
ContextPropertyRegistry contextPropertyRegistry)
{
ExprNodeIdentifierAndStreamRefVisitor visitor = new ExprNodeIdentifierAndStreamRefVisitor(false);
exprNode.Accept(visitor);
AddNonAggregatedProps(set, visitor.Refs, types, contextPropertyRegistry);
}
private static EventAdvancedIndexProvisionCompileTime ValidateAdvanced(
string indexName,
string indexType,
CreateIndexItem columnDesc,
EventType eventType,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// validate index expressions: valid and plain expressions
StreamTypeService streamTypeService = new StreamTypeServiceImpl(eventType, null, false);
var validationContextColumns =
new ExprValidationContextBuilder(streamTypeService, statementRawInfo, services)
.WithDisablePropertyExpressionEventCollCache(true)
.Build();
var columns = columnDesc.Expressions.ToArray();
ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.CREATEINDEXCOLUMN,
columns,
validationContextColumns);
ExprNodeUtilityValidate.ValidatePlainExpression(ExprNodeOrigin.CREATEINDEXCOLUMN, columns);
// validate parameters, may not depend on props
ExprNode[] parameters = null;
if (columnDesc.Parameters != null && !columnDesc.Parameters.IsEmpty()) {
parameters = columnDesc.Parameters.ToArray();
ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.CREATEINDEXPARAMETER,
parameters,
validationContextColumns);
ExprNodeUtilityValidate.ValidatePlainExpression(ExprNodeOrigin.CREATEINDEXPARAMETER, parameters);
// validate no stream dependency of parameters
var visitor = new ExprNodeIdentifierAndStreamRefVisitor(false);
foreach (var param in columnDesc.Parameters) {
param.Accept(visitor);
if (!visitor.Refs.IsEmpty()) {
throw new ExprValidationException("Index parameters may not refer to event properties");
}
}
}
// obtain provider
AdvancedIndexFactoryProvider provider;
try {
provider = services.ImportServiceCompileTime.ResolveAdvancedIndexProvider(indexType);
}
catch (ImportException ex) {
throw new ExprValidationException(ex.Message, ex);
}
return provider.ValidateEventIndex(indexName, indexType, columns, parameters);
}
public static ExprNodePropOrStreamSet GetAggregatedProperties(IList<ExprAggregateNode> aggregateNodes)
{
// Get a list of properties being aggregated in the clause.
ExprNodePropOrStreamSet propertiesAggregated = new ExprNodePropOrStreamSet();
ExprNodeIdentifierAndStreamRefVisitor visitor = new ExprNodeIdentifierAndStreamRefVisitor(true);
foreach (ExprNode selectAggExprNode in aggregateNodes) {
visitor.Reset();
selectAggExprNode.Accept(visitor);
IList<ExprNodePropOrStreamDesc> properties = visitor.Refs;
propertiesAggregated.AddAll(properties);
}
return propertiesAggregated;
}
public FilterExprAnalyzerAffector GetFilterExprAnalyzerAffector()
{
var visitor = new ExprNodeIdentifierAndStreamRefVisitor(false);
foreach (ExprNode lhsNode in _lhs)
{
lhsNode.Accept(visitor);
}
var indexedPropertyStreams = new HashSet <int>();
foreach (ExprNodePropOrStreamDesc @ref in visitor.GetRefs())
{
indexedPropertyStreams.Add(@ref.StreamNum);
}
if (indexedPropertyStreams.Count == 0 || indexedPropertyStreams.Count > 1)
{
return
(null); // there are no properties from any streams that could be used for building an index, or the properties come from different disjoint streams
}
var streamNumIndex = indexedPropertyStreams.First();
var keyExpressions = new List <Pair <ExprNode, int[]> >();
var dependencies = new HashSet <int>();
foreach (ExprNode node in _rhs)
{
visitor.Reset();
dependencies.Clear();
node.Accept(visitor);
foreach (ExprNodePropOrStreamDesc @ref in visitor.GetRefs())
{
dependencies.Add(@ref.StreamNum);
}
if (dependencies.Contains(streamNumIndex))
{
return(null);
}
var pair = new Pair <ExprNode, int[]>(node, CollectionUtil.IntArray(dependencies));
keyExpressions.Add(pair);
}
return(new FilterExprAnalyzerAffectorIndexProvision(OperationName, _lhs, keyExpressions, streamNumIndex));
}
public static ExprNodePropOrStreamSet GetNonAggregatedProps(
EventType[] types,
IList<ExprNode> exprNodes,
ContextPropertyRegistry contextPropertyRegistry)
{
// Determine all event properties in the clause
ExprNodePropOrStreamSet nonAggProps = new ExprNodePropOrStreamSet();
ExprNodeIdentifierAndStreamRefVisitor visitor = new ExprNodeIdentifierAndStreamRefVisitor(false);
foreach (ExprNode node in exprNodes) {
visitor.Reset();
node.Accept(visitor);
AddNonAggregatedProps(nonAggProps, visitor.Refs, types, contextPropertyRegistry);
}
return nonAggProps;
}
private static EventAdvancedIndexProvisionDesc ValidateAdvanced(
string indexName,
string indexType,
CreateIndexItem columnDesc,
EventType eventType,
StatementContext statementContext)
{
// validate index expressions: valid and plain expressions
ExprValidationContext validationContextColumns = GetValidationContext(eventType, statementContext);
ExprNode[] columns = columnDesc.Expressions.ToArray();
ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.CREATEINDEXCOLUMN, columns, validationContextColumns);
ExprNodeUtility.ValidatePlainExpression(ExprNodeOrigin.CREATEINDEXCOLUMN, columns);
// validate parameters, may not depend on props
ExprNode[] parameters = null;
if (columnDesc.Parameters != null && !columnDesc.Parameters.IsEmpty())
{
parameters = columnDesc.Parameters.ToArray();
ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.CREATEINDEXPARAMETER, parameters, validationContextColumns);
ExprNodeUtility.ValidatePlainExpression(ExprNodeOrigin.CREATEINDEXPARAMETER, parameters);
// validate no stream dependency of parameters
var visitor = new ExprNodeIdentifierAndStreamRefVisitor(false);
foreach (ExprNode param in columnDesc.Parameters)
{
param.Accept(visitor);
if (!visitor.GetRefs().IsEmpty())
{
throw new ExprValidationException("Index parameters may not refer to event properties");
}
}
}
// obtain provider
AdvancedIndexFactoryProvider provider;
try {
provider = statementContext.EngineImportService.ResolveAdvancedIndexProvider(indexType);
} catch (EngineImportException ex) {
throw new ExprValidationException(ex.Message, ex);
}
return(provider.ValidateEventIndex(indexName, indexType, columns, parameters));
}
private static bool Prequalify(ExprNode constituent)
{
var prequalify = new FilterSpecExprNodeVisitorBooleanLimitedExprPrequalify();
constituent.Accept(prequalify);
if (!prequalify.IsLimited) {
return false;
}
var streamRefVisitor = new ExprNodeIdentifierAndStreamRefVisitor(false);
constituent.Accept(streamRefVisitor);
var hasStreamRefZero = false;
foreach (var @ref in streamRefVisitor.Refs) {
if (@ref.StreamNum == 0) {
hasStreamRefZero = true;
break;
}
}
return hasStreamRefZero && !streamRefVisitor.HasWildcardOrStreamAlias;
}
public static ExprNodePropOrStreamSet GetGroupByPropertiesValidateHasOne(ExprNode[] groupByNodes)
{
// Get the set of properties refered to by all group-by expression nodes.
ExprNodePropOrStreamSet propertiesGroupBy = new ExprNodePropOrStreamSet();
ExprNodeIdentifierAndStreamRefVisitor visitor = new ExprNodeIdentifierAndStreamRefVisitor(true);
foreach (ExprNode groupByNode in groupByNodes) {
visitor.Reset();
groupByNode.Accept(visitor);
IList<ExprNodePropOrStreamDesc> propertiesNode = visitor.Refs;
propertiesGroupBy.AddAll(propertiesNode);
// For each group-by expression node, require at least one property.
if (propertiesNode.IsEmpty()) {
throw new ExprValidationException("Group-by expressions must refer to property names");
}
}
return propertiesGroupBy;
}
public override IList<StmtClassForgeableFactory> Validate(
StreamTypeService typeService,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
// validate and visit
var validationContext = new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
var visitor = new ExprNodeIdentifierAndStreamRefVisitor(true);
var validatedInputParameters = new List<ExprNode>();
foreach (var exprNode in methodStreamSpec.Expressions) {
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.METHODINVJOIN,
exprNode,
validationContext);
validatedInputParameters.Add(validated);
validated.Accept(visitor);
}
// determine required streams
foreach (ExprNodePropOrStreamDesc @ref in visitor.Refs) {
SubordinateStreams.Add(@ref.StreamNum);
}
// class-based evaluation
MethodInfo targetMethod = null;
if (metadata.MethodProviderClass != null) {
// resolve actual method to use
ExprNodeUtilResolveExceptionHandler handler = new ProxyExprNodeUtilResolveExceptionHandler {
ProcHandle = e => {
if (methodStreamSpec.Expressions.Count == 0) {
return new ExprValidationException(
"Method footprint does not match the number or type of expression parameters, expecting no parameters in method: " +
e.Message);
}
var resultTypes = ExprNodeUtilityQuery.GetExprResultTypes(validatedInputParameters);
return new ExprValidationException(
"Method footprint does not match the number or type of expression parameters, expecting a method where parameters are typed '" +
TypeHelper.GetParameterAsString(resultTypes) +
"': " +
e.Message);
}
};
var desc = ExprNodeUtilityResolve.ResolveMethodAllowWildcardAndStream(
metadata.MethodProviderClass.FullName,
metadata.IsStaticMethod ? null : metadata.MethodProviderClass,
methodStreamSpec.MethodName,
validatedInputParameters,
false,
null,
handler,
methodStreamSpec.MethodName,
@base.StatementRawInfo,
services);
InputParamEvaluators = desc.ChildForges;
targetMethod = desc.ReflectionMethod;
}
else {
// script-based evaluation
InputParamEvaluators = ExprNodeUtilityQuery.GetForges(ExprNodeUtilityQuery.ToArray(validatedInputParameters));
}
// plan multikey
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(InputParamEvaluators, false, @base.StatementRawInfo, services.SerdeResolver);
MultiKeyClassRef = multiKeyPlan.ClassRef;
Pair<MethodTargetStrategyForge, MethodConversionStrategyForge> strategies =
PollExecStrategyPlanner.Plan(metadata, targetMethod, EventType);
target = strategies.First;
conversion = strategies.Second;
return multiKeyPlan.MultiKeyForgeables;
}
