public ExprTableIdentNode GetTableIdentNode(StreamTypeService streamTypeService, string unresolvedPropertyName, string streamOrPropertyName)
{
var propertyPrefixed = unresolvedPropertyName;
if (streamOrPropertyName != null)
{
propertyPrefixed = streamOrPropertyName + "." + unresolvedPropertyName;
}
var col = FindTableColumnMayByPrefixed(streamTypeService, propertyPrefixed);
if (col == null)
{
return(null);
}
var pair = col.Pair;
if (pair.Column is TableMetadataColumnAggregation)
{
var agg = (TableMetadataColumnAggregation)pair.Column;
var node = new ExprTableIdentNode(streamOrPropertyName, unresolvedPropertyName);
var eval = ExprTableEvalStrategyFactory.GetTableAccessEvalStrategy(node, pair.TableMetadata.TableName, pair.StreamNum, agg);
node.Eval = eval;
return(node);
}
return(null);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
// rewrite expression into a table-access expression
if (validationContext.StreamTypeService.HasTableTypes)
{
ExprTableIdentNode tableIdentNode = validationContext.TableService.GetTableIdentNode(validationContext.StreamTypeService, _unresolvedPropertyName, _streamOrPropertyName);
if (tableIdentNode != null)
{
return(tableIdentNode);
}
}
string unescapedPropertyName = PropertyParser.UnescapeBacktick(_unresolvedPropertyName);
Pair <PropertyResolutionDescriptor, string> propertyInfoPair = ExprIdentNodeUtil.GetTypeFromStream(validationContext.StreamTypeService, unescapedPropertyName, _streamOrPropertyName, false);
_resolvedStreamName = propertyInfoPair.Second;
int streamNum = propertyInfoPair.First.StreamNum;
Type propertyType = propertyInfoPair.First.PropertyType;
_resolvedPropertyName = propertyInfoPair.First.PropertyName;
EventPropertyGetter propertyGetter;
try {
propertyGetter = propertyInfoPair.First.StreamEventType.GetGetter(_resolvedPropertyName);
}
catch (PropertyAccessException ex) {
throw new ExprValidationException("Property '" + _unresolvedPropertyName + "' is not valid: " + ex.Message, ex);
}
if (propertyGetter == null)
{
throw new ExprValidationException("Property getter returned was invalid for property '" + _unresolvedPropertyName + "'");
}
var audit = AuditEnum.PROPERTY.GetAudit(validationContext.Annotations);
if (audit != null)
{
_evaluator = new ExprIdentNodeEvaluatorLogging(streamNum, propertyGetter, propertyType, this, _resolvedPropertyName, validationContext.StatementName, validationContext.StreamTypeService.EngineURIQualifier);
}
else
{
_evaluator = new ExprIdentNodeEvaluatorImpl(streamNum, propertyGetter, propertyType, this);
}
// if running in a context, take the property value from context
if (validationContext.ContextDescriptor != null && !validationContext.IsFilterExpression)
{
EventType fromType = validationContext.StreamTypeService.EventTypes[streamNum];
string contextPropertyName = validationContext.ContextDescriptor.ContextPropertyRegistry.GetPartitionContextPropertyName(fromType, _resolvedPropertyName);
if (contextPropertyName != null)
{
EventType contextType = validationContext.ContextDescriptor.ContextPropertyRegistry.ContextEventType;
_evaluator = new ExprIdentNodeEvaluatorContext(streamNum, contextType.GetPropertyType(contextPropertyName), contextType.GetGetter(contextPropertyName));
}
}
return(null);
}
public static Pair <ExprNode, IList <Chainable> > GetTableNodeChainable(
StreamTypeService streamTypeService,
IList <Chainable> chainSpec,
bool allowTableAggReset,
TableCompileTimeResolver tableCompileTimeResolver)
{
chainSpec = new List <Chainable>(chainSpec);
var unresolvedPropertyName = chainSpec[0].GetRootNameOrEmptyString();
var tableStreamNum = streamTypeService.GetStreamNumForStreamName(unresolvedPropertyName);
if (chainSpec.Count == 2 && tableStreamNum != -1)
{
var tableMetadata = tableCompileTimeResolver.ResolveTableFromEventType(streamTypeService.EventTypes[tableStreamNum]);
if (tableMetadata != null && chainSpec[1].GetRootNameOrEmptyString().Equals("reset", StringComparison.InvariantCultureIgnoreCase))
{
if (!allowTableAggReset)
{
throw new ExprValidationException(INVALID_TABLE_AGG_RESET);
}
if (!chainSpec[1].GetParametersOrEmpty().IsEmpty())
{
throw new ExprValidationException(INVALID_TABLE_AGG_RESET_PARAMS);
}
var node = new ExprTableResetRowAggNode(tableMetadata, tableStreamNum);
chainSpec.Clear();
return(new Pair <ExprNode, IList <Chainable> >(node, chainSpec));
}
}
var col = FindTableColumnMayByPrefixed(streamTypeService, unresolvedPropertyName, tableCompileTimeResolver);
var pair = col?.Pair;
if (pair?.Column is TableMetadataColumnAggregation)
{
var agg = (TableMetadataColumnAggregation)pair.Column;
var returnType = pair.TableMetadata.PublicEventType.GetPropertyType(pair.Column.ColumnName);
var node = new ExprTableIdentNode(
pair.TableMetadata,
null,
unresolvedPropertyName,
returnType,
pair.StreamNum,
agg.ColumnName,
agg.Column);
chainSpec.RemoveAt(0);
return(new Pair <ExprNode, IList <Chainable> >(node, chainSpec));
}
return(null);
}
public ExprDotNodeAggregationMethodForgeTableReset(
ExprDotNodeImpl parent,
string aggregationMethodName,
ExprNode[] parameters,
AggregationPortableValidation validation,
ExprTableIdentNode identNode,
TableMetadataColumnAggregation column)
: base(parent, aggregationMethodName, parameters, validation)
{
this.identNode = identNode;
this.column = column;
}
public Pair <ExprNode, IList <ExprChainedSpec> > GetTableNodeChainable(
StreamTypeService streamTypeService,
IList <ExprChainedSpec> chainSpec,
EngineImportService engineImportService)
{
chainSpec = new List <ExprChainedSpec>(chainSpec);
var unresolvedPropertyName = chainSpec[0].Name;
var col = FindTableColumnMayByPrefixed(streamTypeService, unresolvedPropertyName);
if (col == null)
{
return(null);
}
var pair = col.Pair;
if (pair.Column is TableMetadataColumnAggregation)
{
var agg = (TableMetadataColumnAggregation)pair.Column;
if (chainSpec.Count > 1)
{
var candidateAccessor = chainSpec[1].Name;
var exprNode = (ExprAggregateNodeBase)ASTAggregationHelper.TryResolveAsAggregation(engineImportService, false, candidateAccessor, new LazyAllocatedMap <ConfigurationPlugInAggregationMultiFunction, PlugInAggregationMultiFunctionFactory>(), streamTypeService.EngineURIQualifier);
if (exprNode != null)
{
var identNode = new ExprTableIdentNodeSubpropAccessor(pair.StreamNum, col.OptionalStreamName, agg, exprNode);
exprNode.AddChildNodes(chainSpec[1].Parameters);
chainSpec.RemoveAt(0);
chainSpec.RemoveAt(0);
return(new Pair <ExprNode, IList <ExprChainedSpec> >(identNode, chainSpec));
}
}
var node = new ExprTableIdentNode(null, unresolvedPropertyName);
var eval = ExprTableEvalStrategyFactory.GetTableAccessEvalStrategy(node, pair.TableMetadata.TableName, pair.StreamNum, agg);
node.Eval = eval;
chainSpec.RemoveAt(0);
return(new Pair <ExprNode, IList <ExprChainedSpec> >(node, chainSpec));
}
return(null);
}
