protected override IQueryNode PreProcessNode(IQueryNode node)
        {
            if (node is FuzzyQueryNode)
            {
                FuzzyQueryNode     fuzzyNode = (FuzzyQueryNode)node;
                QueryConfigHandler config    = GetQueryConfigHandler();

                FuzzyConfig fuzzyConfig = null;

                if (config != null && (fuzzyConfig = config.Get(ConfigurationKeys.FUZZY_CONFIG)) != null)
                {
                    fuzzyNode.PrefixLength = fuzzyConfig.PrefixLength;

                    if (fuzzyNode.Similarity < 0)
                    {
                        fuzzyNode.Similarity = fuzzyConfig.MinSimilarity;
                    }
                }
                else if (fuzzyNode.Similarity < 0)
                {
                    throw new ArgumentException("No FUZZY_CONFIG set in the config");
                }
            }

            return(node);
        }
Beispiel #2
0
        public virtual Query Build(IQueryNode queryNode)
        {
            FuzzyQueryNode fuzzyNode = (FuzzyQueryNode)queryNode;
            string         text      = fuzzyNode.GetTextAsString();

#pragma warning disable 612, 618
            int numEdits = FuzzyQuery.SingleToEdits(fuzzyNode.Similarity,
                                                    text.CodePointCount(0, text.Length));
#pragma warning restore 612, 618

            return(new FuzzyQuery(new Term(fuzzyNode.GetFieldAsString(), fuzzyNode
                                           .GetTextAsString()), numEdits, fuzzyNode
                                  .PrefixLength));
        }
Beispiel #3
0
        public IQueryNode Term(string field)
        {
            Token          term, boost = null, fuzzySlop = null, goop1, goop2;
            bool           fuzzy = false;
            bool           regexp = false;
            bool           startInc = false;
            bool           endInc = false;
            IQueryNode     q = null;
            FieldQueryNode qLower, qUpper;

#pragma warning disable 612, 618
            float defaultMinSimilarity = Search.FuzzyQuery.DefaultMinSimilarity;
#pragma warning restore 612, 618
            switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
            {
            case RegexpToken.TERM:
            case RegexpToken.REGEXPTERM:
            case RegexpToken.NUMBER:
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.TERM:
                    term = Jj_consume_token(RegexpToken.TERM);
                    q    = new FieldQueryNode(field, EscapeQuerySyntaxImpl.DiscardEscapeChar(term.image), term.beginColumn, term.endColumn);
                    break;

                case RegexpToken.REGEXPTERM:
                    term   = Jj_consume_token(RegexpToken.REGEXPTERM);
                    regexp = true;
                    break;

                case RegexpToken.NUMBER:
                    term = Jj_consume_token(RegexpToken.NUMBER);
                    break;

                default:
                    jj_la1[15] = jj_gen;
                    Jj_consume_token(-1);
                    throw new ParseException();
                }
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.FUZZY_SLOP:
                    fuzzySlop = Jj_consume_token(RegexpToken.FUZZY_SLOP);
                    fuzzy     = true;
                    break;

                default:
                    jj_la1[16] = jj_gen;
                    break;
                }
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.CARAT:
                    Jj_consume_token(RegexpToken.CARAT);
                    boost = Jj_consume_token(RegexpToken.NUMBER);
                    switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                    {
                    case RegexpToken.FUZZY_SLOP:
                        fuzzySlop = Jj_consume_token(RegexpToken.FUZZY_SLOP);
                        fuzzy     = true;
                        break;

                    default:
                        jj_la1[17] = jj_gen;
                        break;
                    }
                    break;

                default:
                    jj_la1[18] = jj_gen;
                    break;
                }
                if (fuzzy)
                {
                    float fms = defaultMinSimilarity;
                    try
                    {
                        fms = Convert.ToSingle(fuzzySlop.image.Substring(1), CultureInfo.InvariantCulture);
                    }
#pragma warning disable 168
                    catch (Exception ignored) { }
#pragma warning restore 168
                    if (fms < 0.0f)
                    {
                        { if (true)
                          {
                              throw new ParseException(new MessageImpl(QueryParserMessages.INVALID_SYNTAX_FUZZY_LIMITS));
                          }
                        }
                    }
                    else if (fms >= 1.0f && fms != (int)fms)
                    {
                        { if (true)
                          {
                              throw new ParseException(new MessageImpl(QueryParserMessages.INVALID_SYNTAX_FUZZY_EDITS));
                          }
                        }
                    }
                    q = new FuzzyQueryNode(field, EscapeQuerySyntaxImpl.DiscardEscapeChar(term.image), fms, term.beginColumn, term.endColumn);
                }
                else if (regexp)
                {
                    string re = term.image.Substring(1, (term.image.Length - 1) - 1);
                    q = new RegexpQueryNode(field, re, 0, re.Length);
                }
                break;

            case RegexpToken.RANGEIN_START:
            case RegexpToken.RANGEEX_START:
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.RANGEIN_START:
                    Jj_consume_token(RegexpToken.RANGEIN_START);
                    startInc = true;
                    break;

                case RegexpToken.RANGEEX_START:
                    Jj_consume_token(RegexpToken.RANGEEX_START);
                    break;

                default:
                    jj_la1[19] = jj_gen;
                    Jj_consume_token(-1);
                    throw new ParseException();
                }
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.RANGE_GOOP:
                    goop1 = Jj_consume_token(RegexpToken.RANGE_GOOP);
                    break;

                case RegexpToken.RANGE_QUOTED:
                    goop1 = Jj_consume_token(RegexpToken.RANGE_QUOTED);
                    break;

                default:
                    jj_la1[20] = jj_gen;
                    Jj_consume_token(-1);
                    throw new ParseException();
                }
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.RANGE_TO:
                    Jj_consume_token(RegexpToken.RANGE_TO);
                    break;

                default:
                    jj_la1[21] = jj_gen;
                    break;
                }
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.RANGE_GOOP:
                    goop2 = Jj_consume_token(RegexpToken.RANGE_GOOP);
                    break;

                case RegexpToken.RANGE_QUOTED:
                    goop2 = Jj_consume_token(RegexpToken.RANGE_QUOTED);
                    break;

                default:
                    jj_la1[22] = jj_gen;
                    Jj_consume_token(-1);
                    throw new ParseException();
                }
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.RANGEIN_END:
                    Jj_consume_token(RegexpToken.RANGEIN_END);
                    endInc = true;
                    break;

                case RegexpToken.RANGEEX_END:
                    Jj_consume_token(RegexpToken.RANGEEX_END);
                    break;

                default:
                    jj_la1[23] = jj_gen;
                    Jj_consume_token(-1);
                    throw new ParseException();
                }
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.CARAT:
                    Jj_consume_token(RegexpToken.CARAT);
                    boost = Jj_consume_token(RegexpToken.NUMBER);
                    break;

                default:
                    jj_la1[24] = jj_gen;
                    break;
                }
                if (goop1.kind == RegexpToken.RANGE_QUOTED)
                {
                    goop1.image = goop1.image.Substring(1, (goop1.image.Length - 1) - 1);
                }
                if (goop2.kind == RegexpToken.RANGE_QUOTED)
                {
                    goop2.image = goop2.image.Substring(1, (goop2.image.Length - 1) - 1);
                }

                qLower = new FieldQueryNode(field,
                                            EscapeQuerySyntaxImpl.DiscardEscapeChar(goop1.image), goop1.beginColumn, goop1.endColumn);
                qUpper = new FieldQueryNode(field,
                                            EscapeQuerySyntaxImpl.DiscardEscapeChar(goop2.image), goop2.beginColumn, goop2.endColumn);
                q = new TermRangeQueryNode(qLower, qUpper, startInc ? true : false, endInc ? true : false);
                break;

            case RegexpToken.QUOTED:
                term = Jj_consume_token(RegexpToken.QUOTED);
                q    = new QuotedFieldQueryNode(field, EscapeQuerySyntaxImpl.DiscardEscapeChar(term.image.Substring(1, (term.image.Length - 1) - 1)), term.beginColumn + 1, term.endColumn - 1);
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.FUZZY_SLOP:
                    fuzzySlop = Jj_consume_token(RegexpToken.FUZZY_SLOP);
                    break;

                default:
                    jj_la1[25] = jj_gen;
                    break;
                }
                switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk)
                {
                case RegexpToken.CARAT:
                    Jj_consume_token(RegexpToken.CARAT);
                    boost = Jj_consume_token(RegexpToken.NUMBER);
                    break;

                default:
                    jj_la1[26] = jj_gen;
                    break;
                }
                int phraseSlop = 0;

                if (fuzzySlop != null)
                {
                    try
                    {
                        phraseSlop = (int)Convert.ToSingle(fuzzySlop.image.Substring(1), CultureInfo.InvariantCulture);
                        q          = new SlopQueryNode(q, phraseSlop);
                    }
#pragma warning disable 168
                    catch (Exception ignored)
#pragma warning restore 168
                    {
                        /* Should this be handled somehow? (defaults to "no PhraseSlop", if
                         * slop number is invalid)
                         */
                    }
                }
                break;

            default:
                jj_la1[27] = jj_gen;
                Jj_consume_token(-1);
                throw new ParseException();
            }
            if (boost != null)
            {
                float f = (float)1.0;
                try
                {
                    f = Convert.ToSingle(boost.image, CultureInfo.InvariantCulture);
                    // avoid boosting null queries, such as those caused by stop words
                    if (q != null)
                    {
                        q = new BoostQueryNode(q, f);
                    }
                }
#pragma warning disable 168
                catch (Exception ignored)
#pragma warning restore 168
                {
                    /* Should this be handled somehow? (defaults to "no boost", if
                     * boost number is invalid)
                     */
                }
            }
            { if (true)
              {
                  return(q);
              }
            }
            throw new Exception("Missing return statement in function");
        }