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));
}
