/// <summary>
/// Constructor.
/// </summary>
/// <param name="lookupable">is the lookupable</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="resultEventIndex">index</param>
/// <param name="statementName">statement name</param>
/// <param name="eventType">event type</param>
/// <throws>ArgumentException if an operator was supplied that does not take a single constant value</throws>
public FilterSpecParamEventPropIndexedForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
string resultEventAsName,
int resultEventIndex,
string resultEventProperty,
EventType eventType,
bool isMustCoerce,
Coercer numberCoercer,
Type coercionType,
string statementName)
: base(lookupable, filterOperator)
{
ResultEventAsName = resultEventAsName;
ResultEventIndex = resultEventIndex;
ResultEventProperty = resultEventProperty;
EventType = eventType;
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 static FilterSpecParamForge HandleRangeNode(
ExprBetweenNode betweenNode,
IDictionary<string, Pair<EventType, string>> taggedEventTypes,
IDictionary<string, Pair<EventType, string>> arrayEventTypes,
ISet<string> allTagNamesOrdered,
string statementName,
StatementRawInfo raw,
StatementCompileTimeServices services)
{
var left = betweenNode.ChildNodes[0];
ExprFilterSpecLookupableForge lookupable = null;
if (left is ExprFilterOptimizableNode) {
var filterOptimizableNode = (ExprFilterOptimizableNode) left;
lookupable = filterOptimizableNode.FilterLookupable;
}
else if (FilterSpecCompilerIndexPlannerHelper.HasLevelOrHint(FilterSpecCompilerIndexPlannerHint.LKUPCOMPOSITE, raw, services) &&
IsLimitedLookupableExpression(left)) {
lookupable = MakeLimitedLookupableForgeMayNull(left, raw, services);
}
if (lookupable == null) {
return null;
}
FilterOperator op = FilterOperatorExtensions.ParseRangeOperator(
betweenNode.IsLowEndpointIncluded,
betweenNode.IsHighEndpointIncluded,
betweenNode.IsNotBetween);
var low = HandleRangeNodeEndpoint(betweenNode.ChildNodes[1], taggedEventTypes, arrayEventTypes, allTagNamesOrdered, statementName, raw, services);
var high = HandleRangeNodeEndpoint(betweenNode.ChildNodes[2], taggedEventTypes, arrayEventTypes, allTagNamesOrdered, statementName, raw, services);
return low == null || high == null ? null : new FilterSpecParamRangeForge(lookupable, op, low, high);
}
protected FilterSpecParamForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator)
{
this.lookupable = lookupable;
this.filterOperator = filterOperator;
}
private static FilterSpecParamForge MakeBooleanExprParam(
ExprNode exprNode,
FilterSpecCompilerArgs args)
{
bool hasSubselectFilterStream = DetermineSubselectFilterStream(exprNode);
bool hasTableAccess = DetermineTableAccessFilterStream(exprNode);
ExprNodeVariableVisitor visitor =
new ExprNodeVariableVisitor(args.compileTimeServices.VariableCompileTimeResolver);
exprNode.Accept(visitor);
bool hasVariable = visitor.IsVariables;
ExprFilterSpecLookupableForge lookupable = new ExprFilterSpecLookupableForge(
PROPERTY_NAME_BOOLEAN_EXPRESSION,
null,
exprNode.Forge.EvaluationType,
false);
return new FilterSpecParamExprNodeForge(
lookupable,
FilterOperator.BOOLEAN_EXPRESSION,
exprNode,
args.taggedEventTypes,
args.arrayEventTypes,
args.streamTypeService,
hasSubselectFilterStream,
hasTableAccess,
hasVariable,
args.compileTimeServices);
}
public FilterSpecParamExprNodeForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
ExprNode exprNode,
IDictionary<string, Pair<EventType, string>> taggedEventTypes,
IDictionary<string, Pair<EventType, string>> arrayEventTypes,
StreamTypeService streamTypeService,
bool hasSubquery,
bool hasTableAccess,
bool hasVariable,
StatementCompileTimeServices compileTimeServices)
: base(lookupable, filterOperator)
{
if (filterOperator != FilterOperator.BOOLEAN_EXPRESSION) {
throw new ArgumentException("Invalid filter operator for filter expression node");
}
ExprNode = exprNode;
TaggedEventTypes = taggedEventTypes;
_arrayEventTypes = arrayEventTypes;
_streamTypeService = streamTypeService;
_hasFilterStreamSubquery = hasSubquery;
_hasTableAccess = hasTableAccess;
_hasVariable = hasVariable;
_compileTimeServices = compileTimeServices;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="lookupable">is the event property or function</param>
/// <param name="filterOperator">is expected to be the IN-list operator</param>
/// <param name="listofValues">is a list of constants and event property names</param>
/// <throws>ArgumentException for illegal args</throws>
public FilterSpecParamInForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
IList<FilterSpecParamInValueForge> listofValues)
: base(lookupable, filterOperator)
{
_listOfValues = listofValues;
foreach (var value in listofValues) {
var returnType = value.ReturnType;
if (returnType.IsCollectionMapOrArray()) {
_hasCollMapOrArray = true;
break;
}
}
if (_hasCollMapOrArray) {
_adders = new FilterSpecParamInAdder[listofValues.Count];
for (var i = 0; i < listofValues.Count; i++) {
var returnType = listofValues[i].ReturnType;
if (returnType == null) {
_adders[i] = InValueAdderPlain.INSTANCE;
}
else if (returnType.IsArray) {
_adders[i] = InValueAdderArray.INSTANCE;
}
else if (returnType.IsGenericDictionary()) {
_adders[i] = InValueAdderMap.INSTANCE;
}
else if (returnType.IsGenericCollection()) {
_adders[i] = InValueAdderColl.INSTANCE;
}
else {
_adders[i] = InValueAdderPlain.INSTANCE;
}
}
}
var isAllConstants = true;
foreach (var value in listofValues) {
if (!value.IsConstant) {
isAllConstants = false;
break;
}
}
if (isAllConstants) {
_inListConstantsOnly = GetFilterValues(null, null);
}
if (filterOperator != FilterOperator.IN_LIST_OF_VALUES &&
filterOperator != FilterOperator.NOT_IN_LIST_OF_VALUES) {
throw new ArgumentException(
"Illegal filter operator " +
filterOperator +
" supplied to " +
"in-values filter parameter");
}
}
public FilterSpecParamValueLimitedExprForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
ExprNode value,
MatchedEventConvertorForge convertor,
Coercer numberCoercer)
: base(lookupable, filterOperator)
{
this._value = value;
this._convertor = convertor;
this._numberCoercer = numberCoercer;
}
public FilterSpecParamAdvancedIndexQuadTreePointRegionForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
FilterSpecParamFilterForEvalDoubleForge xEval,
FilterSpecParamFilterForEvalDoubleForge yEval)
: base(
lookupable,
filterOperator)
{
_xEval = xEval;
_yEval = yEval;
}
public FilterSpecParamContextPropForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
string propertyName,
EventPropertyGetterSPI getter,
Coercer numberCoercer)
: base(lookupable, filterOperator)
{
_getter = getter;
_numberCoercer = numberCoercer;
_propertyName = propertyName;
}
public FilterSpecParamDeployTimeConstParamForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
ExprNodeDeployTimeConst deployTimeConstant,
Type returnType,
Coercer numberCoercer)
: base(
lookupable,
filterOperator)
{
_deployTimeConstant = deployTimeConstant;
_returnType = returnType;
_numberCoercer = numberCoercer;
}
public FilterSpecParamAdvancedIndexQuadTreeMXCIFForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
FilterSpecParamFilterForEvalDoubleForge xEval,
FilterSpecParamFilterForEvalDoubleForge yEval,
FilterSpecParamFilterForEvalDoubleForge widthEval,
FilterSpecParamFilterForEvalDoubleForge heightEval)
:
base(lookupable, filterOperator)
{
_xEval = xEval;
_yEval = yEval;
_widthEval = widthEval;
_heightEval = heightEval;
}
public FilterSpecParamConstantForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
object filterConstant)
: base(lookupable, filterOperator)
{
FilterConstant = filterConstant;
if (filterOperator.IsRangeOperator()) {
throw new ArgumentException(
"Illegal filter operator " +
filterOperator +
" supplied to " +
"constant filter parameter");
}
}
internal static FilterSpecParamForge HandleBooleanLimited(
ExprNode constituent,
IDictionary<string, Pair<EventType, string>> taggedEventTypes,
IDictionary<string, Pair<EventType, string>> arrayEventTypes,
ISet<string> allTagNamesOrdered,
StreamTypeService streamTypeService,
StatementRawInfo raw,
StatementCompileTimeServices services)
{
if (!HasLevelOrHint(FilterSpecCompilerIndexPlannerHint.BOOLCOMPOSITE, raw, services)) {
return null;
}
// prequalify
var prequalified = Prequalify(constituent);
if (!prequalified) {
return null;
}
// determine rewrite
var desc = FindRewrite(constituent);
if (desc == null) {
return null;
}
// there is no value expression, i.e. "select * from SupportBean(theString = intPrimitive)"
if (desc is RewriteDescriptorNoValueExpr) {
var reboolExpression = ExprNodeUtilityPrint.ToExpressionStringMinPrecedence(constituent, new ExprNodeRenderableFlags(false));
var lookupable = new ExprFilterSpecLookupableForge(reboolExpression, null, constituent.Forge, null, true, null);
return new FilterSpecParamValueNullForge(lookupable, FilterOperator.REBOOL);
}
// there is no value expression, i.e. "select * from SupportBean(theString regexp 'abc')"
var withValueExpr = (RewriteDescriptorWithValueExpr) desc;
ExprNode valueExpression = withValueExpr.ValueExpression;
var valueExpressionType = valueExpression.Forge.EvaluationType;
var replacement = new ExprFilterReboolValueNode(valueExpressionType);
ExprNodeUtilityModify.ReplaceChildNode(withValueExpr.ValueExpressionParent, valueExpression, replacement);
var validationContext = new ExprValidationContextBuilder(streamTypeService, raw, services).WithIsFilterExpression(true).Build();
var rebool = ExprNodeUtilityValidate.GetValidatedSubtree(ExprNodeOrigin.FILTER, constituent, validationContext);
DataInputOutputSerdeForge serde = services.SerdeResolver.SerdeForFilter(valueExpressionType, raw);
var convertor = GetMatchEventConvertor(valueExpression, taggedEventTypes, arrayEventTypes, allTagNamesOrdered);
var reboolExpressionX = ExprNodeUtilityPrint.ToExpressionStringMinPrecedence(constituent, new ExprNodeRenderableFlags(false));
var lookupableX = new ExprFilterSpecLookupableForge(reboolExpressionX, null, rebool.Forge, valueExpressionType, true, serde);
return new FilterSpecParamValueLimitedExprForge(lookupableX, FilterOperator.REBOOL, valueExpression, convertor, null);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="lookupable">is the lookupable</param>
/// <param name="filterOperator">is the type of range operator</param>
/// <param name="min">is the begin point of the range</param>
/// <param name="max">is the end point of the range</param>
/// <throws>ArgumentException if an operator was supplied that does not take a double range value</throws>
public FilterSpecParamRangeForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator,
FilterSpecParamFilterForEvalForge min,
FilterSpecParamFilterForEvalForge max)
: base(lookupable, filterOperator)
{
_min = min;
_max = max;
if (!filterOperator.IsRangeOperator() && !filterOperator.IsInvertedRangeOperator()) {
throw new ArgumentException(
"Illegal filter operator " +
filterOperator +
" supplied to " +
"range filter parameter");
}
}
// expressions automatically coerce to the most upwards type
// filters require the same type
internal static object HandleConstantsCoercion(
ExprFilterSpecLookupableForge lookupable,
object constant)
{
var identNodeType = lookupable.ReturnType;
if (!identNodeType.IsNumeric()) {
return constant; // no coercion required, other type checking performed by expression this comes from
}
if (constant == null) {
// null constant type
return null;
}
if (!constant.GetType().CanCoerce(identNodeType)) {
ThrowConversionError(constant.GetType(), identNodeType, lookupable.Expression);
}
var identNodeTypeBoxed = identNodeType.GetBoxedType();
return TypeHelper.CoerceBoxed(constant, identNodeTypeBoxed);
}
public static void ValidateContextDesc(
string contextName,
ContextSpecHash hashedSpec,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
if (hashedSpec.Items.IsEmpty()) {
throw new ExprValidationException("Empty list of hash items");
}
foreach (var item in hashedSpec.Items) {
Chainable chainable = item.Function;
// determine type of hash to use
var hashFuncName = chainable.GetRootNameOrEmptyString();
var hashFuncParams = chainable.GetParametersOrEmpty();
var hashFunction = HashFunctionEnumExtensions.Determine(contextName, hashFuncName);
Pair<Type, ImportSingleRowDesc> hashSingleRowFunction = null;
if (hashFunction == null) {
try {
hashSingleRowFunction = services.ImportServiceCompileTime.ResolveSingleRow(
hashFuncName, services.ClassProvidedExtension);
}
catch (Exception) {
// expected
}
if (hashSingleRowFunction == null) {
throw new ExprValidationException(
"For context '" +
contextName +
"' expected a hash function that is any of {" +
HashFunctionEnumExtensions.GetStringList() +
"} or a plug-in single-row function or script but received '" +
hashFuncName +
"'");
}
}
if (hashFuncParams.IsEmpty()) {
throw new ExprValidationException(
$"For context '{contextName}' expected one or more parameters to the hash function, but found no parameter list");
}
// get first parameter
var paramExpr = hashFuncParams[0];
var paramType = paramExpr.Forge.EvaluationType;
EventPropertyValueGetterForge getter;
if (hashFunction == HashFunctionEnum.CONSISTENT_HASH_CRC32) {
if (hashFuncParams.Count > 1 || paramType != typeof(string)) {
getter = new ContextControllerHashedGetterCRC32SerializedForge(
hashFuncParams,
hashedSpec.Granularity);
}
else {
getter = new ContextControllerHashedGetterCRC32SingleForge(
paramExpr, hashedSpec.Granularity);
}
}
else if (hashFunction == HashFunctionEnum.HASH_CODE) {
if (hashFuncParams.Count > 1) {
getter = new ContextControllerHashedGetterHashMultiple(
hashFuncParams,
hashedSpec.Granularity);
}
else {
getter = new ContextControllerHashedGetterHashSingleForge(paramExpr, hashedSpec.Granularity);
}
}
else if (hashSingleRowFunction != null) {
getter = new ContextControllerHashedGetterSingleRowForge(
hashSingleRowFunction,
hashFuncParams,
hashedSpec.Granularity,
item.FilterSpecCompiled.FilterForEventType,
statementRawInfo,
services);
}
else {
throw new ArgumentException("Unrecognized hash code function '" + hashFuncName + "'");
}
// create and register expression
var expression = hashFuncName + "(" + ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(paramExpr) + ")";
var valueSerde = new DataInputOutputSerdeForgeSingleton(typeof(DIONullableIntegerSerde));
var eval = new ExprEventEvaluatorForgeFromProp(getter);
var lookupable = new ExprFilterSpecLookupableForge(expression, eval, null, typeof(int), true, valueSerde);
item.Lookupable = lookupable;
}
}
internal static FilterSpecParamForge HandleInSetNode(
ExprInNode constituent,
IDictionary <string, Pair <EventType, string> > taggedEventTypes,
IDictionary <string, Pair <EventType, string> > arrayEventTypes,
ISet <string> allTagNamesOrdered,
StatementRawInfo raw,
StatementCompileTimeServices services)
{
var left = constituent.ChildNodes[0];
ExprFilterSpecLookupableForge lookupable = null;
if (left is ExprFilterOptimizableNode)
{
var filterOptimizableNode = (ExprFilterOptimizableNode)left;
lookupable = filterOptimizableNode.FilterLookupable;
}
else if (FilterSpecCompilerIndexPlannerHelper.HasLevelOrHint(FilterSpecCompilerIndexPlannerHint.LKUPCOMPOSITE, raw, services) &&
IsLimitedLookupableExpression(left))
{
lookupable = MakeLimitedLookupableForgeMayNull(left, raw, services);
}
if (lookupable == null)
{
return(null);
}
var op = FilterOperator.IN_LIST_OF_VALUES;
if (constituent.IsNotIn)
{
op = FilterOperator.NOT_IN_LIST_OF_VALUES;
}
var expectedNumberOfConstants = constituent.ChildNodes.Length - 1;
IList <FilterSpecParamInValueForge> listofValues = new List <FilterSpecParamInValueForge>();
var it = Arrays.AsList(constituent.ChildNodes).GetEnumerator();
it.MoveNext(); // ignore the first node as it's the identifier
while (it.MoveNext())
{
var subNode = it.Current;
if (subNode.Forge.ForgeConstantType.IsCompileTimeConstant)
{
var constant = subNode.Forge.ExprEvaluator.Evaluate(null, true, null);
if (constant is ICollection <object> )
{
return(null);
}
if (constant is IDictionary <object, object> )
{
return(null);
}
if ((constant != null) && (constant is Array arrayConstant))
{
for (var i = 0; i < arrayConstant.Length; i++)
{
var arrayElement = arrayConstant.GetValue(i);
var arrayElementCoerced = HandleConstantsCoercion(lookupable, arrayElement);
listofValues.Add(new FilterForEvalConstantAnyTypeForge(arrayElementCoerced));
if (i > 0)
{
expectedNumberOfConstants++;
}
}
}
else
{
constant = HandleConstantsCoercion(lookupable, constant);
listofValues.Add(new FilterForEvalConstantAnyTypeForge(constant));
}
}
else if (subNode is ExprContextPropertyNode)
{
var contextPropertyNode = (ExprContextPropertyNode)subNode;
var returnType = contextPropertyNode.Type;
Coercer coercer;
if (TypeHelper.IsCollectionMapOrArray(returnType))
{
CheckArrayCoercion(returnType, lookupable.ReturnType, lookupable.Expression);
coercer = null;
}
else
{
coercer = GetNumberCoercer(left.Forge.EvaluationType, contextPropertyNode.Type, lookupable.Expression);
}
var finalReturnType = coercer != null ? coercer.ReturnType : returnType;
listofValues.Add(new FilterForEvalContextPropForge(contextPropertyNode.PropertyName, contextPropertyNode.Getter, coercer, finalReturnType));
}
else if (subNode.Forge.ForgeConstantType.IsDeployTimeTimeConstant && subNode is ExprNodeDeployTimeConst)
{
var deployTimeConst = (ExprNodeDeployTimeConst)subNode;
var returnType = subNode.Forge.EvaluationType;
Coercer coercer;
if (TypeHelper.IsCollectionMapOrArray(returnType))
{
CheckArrayCoercion(returnType, lookupable.ReturnType, lookupable.Expression);
coercer = null;
}
else
{
coercer = GetNumberCoercer(left.Forge.EvaluationType, returnType, lookupable.Expression);
}
listofValues.Add(new FilterForEvalDeployTimeConstForge(deployTimeConst, coercer, returnType));
}
else if (subNode is ExprIdentNode)
{
var identNodeInner = (ExprIdentNode)subNode;
if (identNodeInner.StreamId == 0)
{
break; // for same event evals use the boolean expression, via count compare failing below
}
var isMustCoerce = false;
var coerceToType = Boxing.GetBoxedType(lookupable.ReturnType);
var identReturnType = identNodeInner.Forge.EvaluationType;
if (TypeHelper.IsCollectionMapOrArray(identReturnType))
{
CheckArrayCoercion(identReturnType, lookupable.ReturnType, lookupable.Expression);
coerceToType = identReturnType;
// no action
}
else if (identReturnType != lookupable.ReturnType)
{
if (TypeHelper.IsNumeric(lookupable.ReturnType))
{
if (!TypeHelper.CanCoerce(identReturnType, lookupable.ReturnType))
{
ThrowConversionError(identReturnType, lookupable.ReturnType, lookupable.Expression);
}
isMustCoerce = true;
}
else
{
break; // assumed not compatible
}
}
FilterSpecParamInValueForge inValue;
var streamName = identNodeInner.ResolvedStreamName;
if (arrayEventTypes != null && !arrayEventTypes.IsEmpty() && arrayEventTypes.ContainsKey(streamName))
{
var indexAndProp = GetStreamIndex(identNodeInner.ResolvedPropertyName);
var innerEventType = GetArrayInnerEventType(arrayEventTypes, streamName);
inValue = new FilterForEvalEventPropIndexedForge(
identNodeInner.ResolvedStreamName,
indexAndProp.First,
indexAndProp.Second,
innerEventType,
isMustCoerce,
coerceToType);
}
else
{
inValue = new FilterForEvalEventPropForge(
identNodeInner.ResolvedStreamName,
identNodeInner.ResolvedPropertyName,
identNodeInner.ExprEvaluatorIdent,
isMustCoerce,
coerceToType);
}
listofValues.Add(inValue);
}
else if (FilterSpecCompilerIndexPlannerHelper.HasLevelOrHint(FilterSpecCompilerIndexPlannerHint.VALUECOMPOSITE, raw, services) &&
IsLimitedValueExpression(subNode))
{
var convertor = GetMatchEventConvertor(subNode, taggedEventTypes, arrayEventTypes, allTagNamesOrdered);
var valueType = subNode.Forge.EvaluationType;
var lookupableType = lookupable.ReturnType;
var numberCoercer = GetNumberCoercer(lookupableType, valueType, lookupable.Expression);
var forge = new FilterForEvalLimitedExprForge(subNode, convertor, numberCoercer);
listofValues.Add(forge);
}
}
// Fallback if not all values in the in-node can be resolved to properties or constants
if (listofValues.Count == expectedNumberOfConstants)
{
return(new FilterSpecParamInForge(lookupable, op, listofValues));
}
return(null);
}
public FilterSpecParamValueNullForge(
ExprFilterSpecLookupableForge lookupable,
FilterOperator filterOperator)
: base(lookupable, filterOperator)
{
}
