Пример #1
0
        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)));
        }
Пример #2
0
        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));
 }
Пример #9
0
 protected abstract TResult Transform(FilterTextExpression tx);
 protected static bool UseCaseInsensitiveRegexMatching(FilterTextExpression optTxt, FilterTextMatching matching)
 {
     return(!(matching == FilterTextMatching.RegularExpression ||
              optTxt?.Matching == FilterTextMatching.Exact));
 }