static FilterExpression Like(FilterExpression lhs, FilterTextExpression rhs)
{
if (!rhs.Text.Contains('%') && !rhs.Text.Contains('_'))
{
return(new FilterCallExpression(Operators.OpEqual, lhs, new FilterTextExpression(rhs.Text, FilterTextMatching.Insensitive)));
}
if (rhs.Text.Length > 1 && !rhs.Text.Contains('_'))
{
var count = rhs.Text.Count(ch => ch == '%');
if (count == 1)
{
var idx = rhs.Text.IndexOf('%');
var rest = rhs.Text.Remove(idx, 1);
if (idx == 0)
{
return(new FilterCallExpression(Operators.OpEndsWith, lhs,
new FilterTextExpression(rest, FilterTextMatching.Insensitive)));
}
if (idx == rhs.Text.Length - 1)
{
return(new FilterCallExpression(Operators.OpStartsWith, lhs,
new FilterTextExpression(rest, FilterTextMatching.Insensitive)));
}
}
else if (count == 2 && rhs.Text.Length > 2)
{
if (rhs.Text.StartsWith("%") && rhs.Text.EndsWith("%"))
{
return(new FilterCallExpression(Operators.OpContains, lhs,
new FilterTextExpression(rhs.Text.Substring(1, rhs.Text.Length - 2), FilterTextMatching.Insensitive)));
}
}
}
var regex = "";
foreach (var ch in rhs.Text)
{
if (ch == '%')
{
regex += "(.|\\r|\\n)*"; // ~= RegexOptions.Singleline
}
else if (ch == '_')
{
regex += '.';
}
else
{
regex += Regex.Escape(ch.ToString());
}
}
return(new FilterCallExpression(Operators.OpEqual, lhs, new FilterTextExpression(regex, FilterTextMatching.RegularExpressionInsensitive)));
}
protected override FilterExpression Transform(FilterTextExpression tx)
{
if (tx == _source)
{
return(_dest);
}
return(base.Transform(tx));
}
protected static bool UseCaseInsensitiveTextMatching(FilterTextExpression tx0, FilterTextExpression tx1)
{
if (tx0 == null && tx1 == null)
{
return(false);
}
return(!(tx0?.Matching == FilterTextMatching.Exact || tx1?.Matching == FilterTextMatching.Exact));
}
protected override FilterExpressionCosting Transform(FilterTextExpression tx)
{
switch (tx.Matching)
{
case FilterTextMatching.Insensitive:
return(new FilterExpressionCosting(tx, 2));
case FilterTextMatching.RegularExpression:
case FilterTextMatching.RegularExpressionInsensitive:
return(new FilterExpressionCosting(tx, 10000));
}
return(new FilterExpressionCosting(tx, 1));
}
protected override Expression <CompiledFilterExpression> Transform(FilterTextExpression tx)
{
throw new InvalidOperationException("FilterTextExpression must be transformed prior to compilation.");
}
protected override FilterExpression Transform(FilterTextExpression tx)
{
return(tx);
}
protected override FilterCallExpression Transform(FilterTextExpression tx)
{
return(null);
}
protected override FilterExpression Transform(FilterTextExpression tx)
{
// Since at this point the value is not being used in any matching-compatible
// operation, it doesn't matter what the matching mode is.
return(new FilterConstantExpression(tx.Text));
}
protected abstract TResult Transform(FilterTextExpression tx);
protected static bool UseCaseInsensitiveRegexMatching(FilterTextExpression optTxt, FilterTextMatching matching)
{
return(!(matching == FilterTextMatching.RegularExpression ||
optTxt?.Matching == FilterTextMatching.Exact));
}
