private Filter Convert(ScriptNode Node, Variables Variables) { string FieldName; object Value; if (Node is null) { return(null); } else if (Node is And And) { return(new FilterAnd(this.Convert(And.LeftOperand, Variables), this.Convert(And.RightOperand, Variables))); } else if (Node is Or Or) { return(new FilterOr(this.Convert(Or.LeftOperand, Variables), this.Convert(Or.RightOperand, Variables))); } else if (Node is Operators.Dual.And And2) { return(new FilterAnd(this.Convert(And2.LeftOperand, Variables), this.Convert(And2.RightOperand, Variables))); } else if (Node is Operators.Dual.Or Or2) { return(new FilterOr(this.Convert(Or2.LeftOperand, Variables), this.Convert(Or2.RightOperand, Variables))); } else if (Node is Not Not) { return(new FilterNot(this.Convert(Not.Operand, Variables))); } else if (Node is EqualTo EQ) { this.CheckBinaryOperator(EQ, Variables, out FieldName, out Value); return(new FilterFieldEqualTo(FieldName, Value)); } else if (Node is NotEqualTo NEQ) { this.CheckBinaryOperator(NEQ, Variables, out FieldName, out Value); return(new FilterFieldNotEqualTo(FieldName, Value)); } else if (Node is LesserThan LT) { this.CheckBinaryOperator(LT, Variables, out FieldName, out Value); return(new FilterFieldLesserThan(FieldName, Value)); } else if (Node is GreaterThan GT) { this.CheckBinaryOperator(GT, Variables, out FieldName, out Value); return(new FilterFieldGreaterThan(FieldName, Value)); } else if (Node is LesserThanOrEqualTo LTE) { this.CheckBinaryOperator(LTE, Variables, out FieldName, out Value); return(new FilterFieldLesserOrEqualTo(FieldName, Value)); } else if (Node is GreaterThanOrEqualTo GTE) { this.CheckBinaryOperator(GTE, Variables, out FieldName, out Value); return(new FilterFieldGreaterOrEqualTo(FieldName, Value)); } else if (Node is Range Range) { this.CheckTernaryOperator(Range, Variables, out FieldName, out object Min, out object Max); Filter[] Filters = new Filter[2]; if (Range.LeftInclusive) { Filters[0] = new FilterFieldGreaterOrEqualTo(FieldName, Min); } else { Filters[0] = new FilterFieldGreaterThan(FieldName, Min); } if (Range.RightInclusive) { Filters[1] = new FilterFieldLesserOrEqualTo(FieldName, Max); } else { Filters[1] = new FilterFieldLesserThan(FieldName, Max); } return(new FilterAnd(Filters)); } else if (Node is Like) { this.CheckBinaryOperator((BinaryOperator)Node, Variables, out FieldName, out Value); string RegEx = Database.WildcardToRegex(Value is string s ? s : Expression.ToString(Value), "*"); return(new FilterFieldLikeRegEx(FieldName, RegEx)); } else if (Node is NotLike) { this.CheckBinaryOperator((BinaryOperator)Node, Variables, out FieldName, out Value); string RegEx = Database.WildcardToRegex(Value is string s ? s : Expression.ToString(Value), "*"); return(new FilterNot(new FilterFieldLikeRegEx(FieldName, RegEx))); } else { throw new ScriptRuntimeException("Invalid operation for filters: " + Node.GetType().FullName, this); } }
internal static Filter Convert(ScriptNode Conditions, Variables Variables, string Name) { if (Conditions is null) { return(null); } if (Conditions is TernaryOperator Tercery) { if (Conditions is Operators.Comparisons.Range Range && Range.MiddleOperand is VariableReference Ref) { ScriptNode LO = Reduce(Range.LeftOperand, Name); ScriptNode RO = Reduce(Range.RightOperand, Name); string FieldName = Ref.VariableName; object Min = LO.Evaluate(Variables)?.AssociatedObjectValue ?? null; object Max = RO.Evaluate(Variables)?.AssociatedObjectValue ?? null; Filter[] Filters = new Filter[2]; if (Range.LeftInclusive) { Filters[0] = new FilterFieldGreaterOrEqualTo(Ref.VariableName, Min); } else { Filters[0] = new FilterFieldGreaterThan(Ref.VariableName, Min); } if (Range.RightInclusive) { Filters[1] = new FilterFieldLesserOrEqualTo(Ref.VariableName, Max); } else { Filters[1] = new FilterFieldLesserThan(Ref.VariableName, Max); } return(new FilterAnd(Filters)); } } else if (Conditions is BinaryOperator Bin) { ScriptNode LO = Reduce(Bin.LeftOperand, Name); ScriptNode RO = Reduce(Bin.RightOperand, Name); if (Conditions is Operators.Logical.And || Conditions is Operators.Dual.And) { Filter L = Convert(LO, Variables, Name); Filter R = Convert(RO, Variables, Name); List <Filter> Filters = new List <Filter>(); if (L is FilterAnd L2) { Filters.AddRange(L2.ChildFilters); } else { Filters.Add(L); } if (R is FilterAnd R2) { Filters.AddRange(R2.ChildFilters); } else { Filters.Add(R); } return(new FilterAnd(Filters.ToArray())); } if (Conditions is Operators.Logical.Or || Conditions is Operators.Dual.Or) { Filter L = Convert(LO, Variables, Name); Filter R = Convert(RO, Variables, Name); List <Filter> Filters = new List <Filter>(); if (L is FilterOr L2) { Filters.AddRange(L2.ChildFilters); } else { Filters.Add(L); } if (R is FilterOr R2) { Filters.AddRange(R2.ChildFilters); } else { Filters.Add(R); } return(new FilterOr(Filters.ToArray())); } if (LO is VariableReference LVar) { string FieldName = LVar.VariableName; object Value = RO.Evaluate(Variables)?.AssociatedObjectValue ?? null; if (Conditions is Operators.Comparisons.EqualTo || Conditions is Operators.Comparisons.EqualToElementWise || Conditions is Operators.Comparisons.IdenticalTo || Conditions is Operators.Comparisons.IdenticalToElementWise) { return(new FilterFieldEqualTo(FieldName, Value)); } else if (Conditions is Operators.Comparisons.NotEqualTo || Conditions is Operators.Comparisons.NotEqualToElementWise) { return(new FilterFieldNotEqualTo(FieldName, Value)); } else if (Conditions is Operators.Comparisons.GreaterThan) { return(new FilterFieldGreaterThan(FieldName, Value)); } else if (Conditions is Operators.Comparisons.GreaterThanOrEqualTo) { return(new FilterFieldGreaterOrEqualTo(FieldName, Value)); } else if (Conditions is Operators.Comparisons.LesserThan) { return(new FilterFieldLesserThan(FieldName, Value)); } else if (Conditions is Operators.Comparisons.LesserThanOrEqualTo) { return(new FilterFieldLesserOrEqualTo(FieldName, Value)); } else if (Conditions is Operators.Comparisons.Like Like) { string RegEx = WildcardToRegex(Value is string s ? s : Expression.ToString(Value), "%"); Like.TransformExpression += (Expression) => WildcardToRegex(Expression, "%"); return(new FilterFieldLikeRegEx(FieldName, RegEx)); } else if (Conditions is Operators.Comparisons.NotLike NotLike) { string RegEx = WildcardToRegex(Value is string s ? s : Expression.ToString(Value), "%"); NotLike.TransformExpression += (Expression) => WildcardToRegex(Expression, "%"); return(new FilterNot(new FilterFieldLikeRegEx(FieldName, RegEx))); } } else if (RO is VariableReference RVar) { string FieldName = RVar.VariableName; object Value = LO.Evaluate(Variables)?.AssociatedObjectValue ?? null; if (Conditions is Operators.Comparisons.EqualTo || Conditions is Operators.Comparisons.EqualToElementWise || Conditions is Operators.Comparisons.IdenticalTo || Conditions is Operators.Comparisons.IdenticalToElementWise) { return(new FilterFieldEqualTo(FieldName, Value)); } else if (Conditions is Operators.Comparisons.NotEqualTo || Conditions is Operators.Comparisons.NotEqualToElementWise) { return(new FilterFieldNotEqualTo(FieldName, Value)); } else if (Conditions is Operators.Comparisons.GreaterThan) { return(new FilterFieldLesserThan(FieldName, Value)); } else if (Conditions is Operators.Comparisons.GreaterThanOrEqualTo) { return(new FilterFieldLesserOrEqualTo(FieldName, Value)); } else if (Conditions is Operators.Comparisons.LesserThan) { return(new FilterFieldGreaterThan(FieldName, Value)); } else if (Conditions is Operators.Comparisons.LesserThanOrEqualTo) { return(new FilterFieldGreaterOrEqualTo(FieldName, Value)); } else if (Conditions is Operators.Comparisons.Like Like) { string RegEx = WildcardToRegex(Value is string s ? s : Expression.ToString(Value), "%"); Like.TransformExpression += (Expression) => WildcardToRegex(Expression, "%"); return(new FilterFieldLikeRegEx(FieldName, RegEx)); } else if (Conditions is Operators.Comparisons.NotLike NotLike) { string RegEx = WildcardToRegex(Value is string s ? s : Expression.ToString(Value), "%"); NotLike.TransformExpression += (Expression) => WildcardToRegex(Expression, "%"); return(new FilterNot(new FilterFieldLikeRegEx(FieldName, RegEx))); } } } else if (Conditions is UnaryOperator UnOp) { if (Conditions is Operators.Logical.Not Not) { Filter F = Convert(Reduce(Not.Operand, Name), Variables, Name); if (F is FilterNot Not2) { return(Not2.ChildFilter); } else { return(new FilterNot(F)); } } } else if (Conditions is VariableReference Ref) { return(new FilterFieldEqualTo(Ref.VariableName, true)); } return(new FilterCustom <object>(new ScriptNodeFilter(Conditions, Variables).Passes)); }