public static CreateIndexDesc Walk(EsperEPL2GrammarParser.CreateIndexExprContext ctx, IDictionary <ITree, ExprNode> astExprNodeMap)
{
var indexName = ctx.n.Text;
var windowName = ctx.w.Text;
var unique = false;
if (ctx.u != null)
{
string ident = ctx.u.Text;
if (ident.ToLowerInvariant().Trim() == "unique")
{
unique = true;
}
else
{
throw ASTWalkException.From("Invalid keyword '" + ident + "' in create-index encountered, expected 'unique'");
}
}
var columns = new List <CreateIndexItem>();
var cols = ctx.createIndexColumnList().createIndexColumn();
foreach (var col in cols)
{
CreateIndexItem item = Walk(col, astExprNodeMap);
columns.Add(item);
}
return(new CreateIndexDesc(unique, indexName, windowName, columns));
}
private static void ValidateBuiltin(
CreateIndexItem columnDesc,
EventType eventType,
IList <IndexedPropDesc> hashProps,
IList <IndexedPropDesc> btreeProps,
ISet <string> indexedColumns)
{
if (columnDesc.Expressions.IsEmpty())
{
throw new ExprValidationException("Invalid empty list of index expressions");
}
if (columnDesc.Expressions.Count > 1)
{
throw new ExprValidationException("Invalid multiple index expressions for index type '" + columnDesc.IndexType + "'");
}
ExprNode expression = columnDesc.Expressions[0];
if (!(expression is ExprIdentNode))
{
throw new ExprValidationException("Invalid index expression '" + expression.ToExpressionStringMinPrecedenceSafe() + "'");
}
ExprIdentNode identNode = (ExprIdentNode)expression;
if (identNode.FullUnresolvedName.Contains("."))
{
throw new ExprValidationException("Invalid index expression '" + expression.ToExpressionStringMinPrecedenceSafe() + "'");
}
string columnName = identNode.FullUnresolvedName;
Type type = eventType.GetPropertyType(columnName).GetBoxedType();
if (type == null)
{
throw new ExprValidationException("Property named '" + columnName + "' not found");
}
if (!indexedColumns.Add(columnName))
{
throw new ExprValidationException("Property named '" + columnName + "' has been declared more then once");
}
var desc = new IndexedPropDesc(columnName, type);
string indexType = columnDesc.IndexType;
if (string.Equals(indexType, CreateIndexType.HASH.ToString(), StringComparison.InvariantCultureIgnoreCase))
{
hashProps.Add(desc);
}
else
{
btreeProps.Add(desc);
}
}
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);
}
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));
}
