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