/// <summary>
/// Constructor.
/// </summary>
/// <param name="lookupable">is the property or function to get a lookup value</param>
/// <param name="filterOperator">is the type of compare</param>
/// <param name="resultEventAsName">is the name of the result event from which to get a property value to compare</param>
/// <param name="resultEventProperty">is the name of the property to get from the named result event</param>
/// <param name="isMustCoerce">indicates on whether numeric coercion must be performed</param>
/// <param name="coercionType">indicates the numeric coercion type to use</param>
/// <param name="numberCoercer">interface to use to perform coercion</param>
/// <param name="statementName">statement name</param>
/// <param name="exprIdentNodeEvaluator">evaluator</param>
/// <throws>ArgumentException if an operator was supplied that does not take a single constant value</throws>
public FilterSpecParamEventPropForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
string resultEventAsName,
string resultEventProperty,
ExprIdentNodeEvaluator exprIdentNodeEvaluator,
bool isMustCoerce,
Coercer numberCoercer,
Type coercionType,
string statementName)
: base(lookupable, filterOperator)
{
ResultEventAsName = resultEventAsName;
ResultEventProperty = resultEventProperty;
ExprIdentNodeEvaluator = exprIdentNodeEvaluator;
IsMustCoerce = isMustCoerce;
_numberCoercer = numberCoercer;
CoercionType = coercionType;
_statementName = statementName;
if (filterOperator.IsRangeOperator()) {
throw new ArgumentException(
"Illegal filter operator " +
filterOperator +
" supplied to " +
"event property filter parameter");
}
}
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 FilterForEvalEventPropDoubleForge(
string resultEventAsName,
string resultEventProperty,
ExprIdentNodeEvaluator exprIdentNodeEvaluator)
{
ResultEventAsName = resultEventAsName;
ResultEventProperty = resultEventProperty;
_exprIdentNodeEvaluator = exprIdentNodeEvaluator;
}
public FilterForEvalEventPropForge(
string resultEventAsName,
string resultEventProperty,
ExprIdentNodeEvaluator exprIdentNodeEvaluator,
bool isMustCoerce,
Type coercionType)
{
_resultEventAsName = resultEventAsName;
_resultEventProperty = resultEventProperty;
_exprIdentNodeEvaluator = exprIdentNodeEvaluator;
ReturnType = coercionType;
_isMustCoerce = isMustCoerce;
}
public ExprIdentNodeImpl(EventType eventType, string propertyName, int streamNumber)
{
_unresolvedPropertyName = propertyName;
_resolvedPropertyName = propertyName;
EventPropertyGetter propertyGetter = eventType.GetGetter(propertyName);
if (propertyGetter == null)
{
throw new ArgumentException("Ident-node constructor could not locate property " + propertyName);
}
Type propertyType = eventType.GetPropertyType(propertyName);
_evaluator = new ExprIdentNodeEvaluatorImpl(streamNumber, propertyGetter, propertyType, this);
}
public ExprIdentNodeImpl(
EventType eventType,
string propertyName,
int streamNumber)
{
UnresolvedPropertyName = propertyName;
resolvedPropertyName = propertyName;
var propertyGetter = ((EventTypeSPI) eventType).GetGetterSPI(propertyName);
if (propertyGetter == null) {
throw new ArgumentException("Ident-node constructor could not locate property " + propertyName);
}
var propertyType = eventType.GetPropertyType(propertyName);
evaluator = new ExprIdentNodeEvaluatorImpl(
streamNumber,
propertyGetter,
propertyType.GetBoxedType(),
this,
eventType,
true,
false);
}
