LCOV - code coverage report
Current view: top level - queryparser - queryparser.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core c2b6f1024d3a Lines: 89 93 95.7 %
Date: 2019-05-16 09:13:18 Functions: 23 24 95.8 %
Branches: 47 84 56.0 %

           Branch data     Line data    Source code
       1                 :            : /** @file queryparser.cc
       2                 :            :  * @brief The non-lemon-generated parts of the QueryParser class.
       3                 :            :  */
       4                 :            : /* Copyright (C) 2005,2006,2007,2008,2010,2011,2012,2013,2015,2016 Olly Betts
       5                 :            :  * Copyright (C) 2010 Adam Sj√łgren
       6                 :            :  *
       7                 :            :  * This program is free software; you can redistribute it and/or
       8                 :            :  * modify it under the terms of the GNU General Public License as
       9                 :            :  * published by the Free Software Foundation; either version 2 of the
      10                 :            :  * License, or (at your option) any later version.
      11                 :            :  *
      12                 :            :  * This program is distributed in the hope that it will be useful,
      13                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            :  * GNU General Public License for more details.
      16                 :            :  *
      17                 :            :  * You should have received a copy of the GNU General Public License
      18                 :            :  * along with this program; if not, write to the Free Software
      19                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
      20                 :            :  * USA
      21                 :            :  */
      22                 :            : 
      23                 :            : #include <config.h>
      24                 :            : 
      25                 :            : #include "xapian/error.h"
      26                 :            : #include <xapian/queryparser.h>
      27                 :            : #include <xapian/termiterator.h>
      28                 :            : 
      29                 :            : #include "api/vectortermlist.h"
      30                 :            : #include "omassert.h"
      31                 :            : #include "queryparser_internal.h"
      32                 :            : 
      33                 :            : #include <cstring>
      34                 :            : 
      35                 :            : using namespace Xapian;
      36                 :            : 
      37                 :            : using namespace std;
      38                 :            : 
      39                 :            : // Default implementation in case the user hasn't implemented it.
      40                 :            : string
      41                 :          0 : Stopper::get_description() const
      42                 :            : {
      43         [ #  # ]:          0 :     return "Xapian::Stopper subclass";
      44                 :            : }
      45                 :            : 
      46                 :            : string
      47                 :          1 : SimpleStopper::get_description() const
      48                 :            : {
      49         [ +  - ]:          1 :     string desc("Xapian::SimpleStopper(");
      50                 :          1 :     unordered_set<string>::const_iterator i;
      51         [ -  + ]:          1 :     for (i = stop_words.begin(); i != stop_words.end(); ++i) {
      52 [ #  # ][ #  # ]:          0 :         if (i != stop_words.begin()) desc += ' ';
      53         [ #  # ]:          0 :         desc += *i;
      54                 :            :     }
      55         [ +  - ]:          1 :     desc += ')';
      56                 :          1 :     return desc;
      57                 :            : }
      58                 :            : 
      59         [ -  + ]:         60 : RangeProcessor::~RangeProcessor() { }
      60                 :            : 
      61         [ -  + ]:         14 : FieldProcessor::~FieldProcessor() { }
      62                 :            : 
      63                 :            : QueryParser::QueryParser(const QueryParser &) = default;
      64                 :            : 
      65                 :            : QueryParser &
      66                 :            : QueryParser::operator=(const QueryParser &) = default;
      67                 :            : 
      68                 :            : QueryParser::QueryParser(QueryParser &&) = default;
      69                 :            : 
      70                 :            : QueryParser &
      71                 :            : QueryParser::operator=(QueryParser &&) = default;
      72                 :            : 
      73         [ +  - ]:        245 : QueryParser::QueryParser() : internal(new QueryParser::Internal) { }
      74                 :            : 
      75                 :        494 : QueryParser::~QueryParser() { }
      76                 :            : 
      77                 :            : void
      78                 :         29 : QueryParser::set_stemmer(const Xapian::Stem & stemmer)
      79                 :            : {
      80                 :         29 :     internal->stemmer = stemmer;
      81                 :         29 : }
      82                 :            : 
      83                 :            : void
      84                 :         60 : QueryParser::set_stemming_strategy(stem_strategy strategy)
      85                 :            : {
      86                 :         60 :     internal->stem_action = strategy;
      87                 :         60 : }
      88                 :            : 
      89                 :            : void
      90                 :         14 : QueryParser::set_stopper(const Stopper * stopper)
      91                 :            : {
      92                 :         14 :     internal->stopper = stopper;
      93                 :         14 : }
      94                 :            : 
      95                 :            : void
      96                 :         44 : QueryParser::set_default_op(Query::op default_op)
      97                 :            : {
      98         [ +  + ]:         44 :     switch (default_op) {
      99                 :            :         case Query::OP_AND:
     100                 :            :         case Query::OP_OR:
     101                 :            :         case Query::OP_NEAR:
     102                 :            :         case Query::OP_PHRASE:
     103                 :            :         case Query::OP_ELITE_SET:
     104                 :            :         case Query::OP_SYNONYM:
     105                 :            :         case Query::OP_MAX:
     106                 :            :             // These are OK.
     107                 :         36 :             break;
     108                 :            :         default:
     109                 :            :             throw Xapian::InvalidArgumentError(
     110                 :            :                     "QueryParser::set_default_op() only accepts "
     111                 :            :                     "OP_AND"
     112                 :            :                     ", "
     113                 :            :                     "OP_OR"
     114                 :            :                     ", "
     115                 :            :                     "OP_NEAR"
     116                 :            :                     ", "
     117                 :            :                     "OP_PHRASE"
     118                 :            :                     ", "
     119                 :            :                     "OP_ELITE_SET"
     120                 :            :                     ", "
     121                 :            :                     "OP_SYNONYM"
     122                 :            :                     " or "
     123 [ +  - ][ +  - ]:          8 :                     "OP_MAX");
                 [ +  - ]
     124                 :            :     }
     125                 :         36 :     internal->default_op = default_op;
     126                 :         36 : }
     127                 :            : 
     128                 :            : Query::op
     129                 :         14 : QueryParser::get_default_op() const
     130                 :            : {
     131                 :         14 :     return internal->default_op;
     132                 :            : }
     133                 :            : 
     134                 :            : void
     135                 :        183 : QueryParser::set_database(const Database &db) {
     136                 :        183 :     internal->db = db;
     137                 :        183 : }
     138                 :            : 
     139                 :            : void
     140                 :        125 : QueryParser::set_max_expansion(Xapian::termcount max_expansion,
     141                 :            :                                int max_type,
     142                 :            :                                unsigned flags)
     143                 :            : {
     144         [ +  - ]:        125 :     if (flags & FLAG_WILDCARD) {
     145                 :        125 :         internal->max_wildcard_expansion = max_expansion;
     146                 :        125 :         internal->max_wildcard_type = max_type;
     147                 :            :     }
     148         [ +  - ]:        125 :     if (flags & FLAG_PARTIAL) {
     149                 :        125 :         internal->max_partial_expansion = max_expansion;
     150                 :        125 :         internal->max_partial_type = max_type;
     151                 :            :     }
     152         [ +  - ]:        125 :     if (flags & FLAG_FUZZY) {
     153                 :        125 :         internal->max_fuzzy_expansion = max_expansion;
     154                 :        125 :         internal->max_fuzzy_type = max_type;
     155                 :            :     }
     156                 :        125 : }
     157                 :            : 
     158                 :            : void
     159                 :         20 : QueryParser::set_min_wildcard_prefix(unsigned min_prefix_len,
     160                 :            :                                      unsigned flags)
     161                 :            : {
     162         [ +  + ]:         20 :     if (flags & FLAG_WILDCARD) {
     163                 :         15 :         internal->min_wildcard_prefix_len = min_prefix_len;
     164                 :            :     }
     165         [ +  - ]:         20 :     if (flags & FLAG_PARTIAL) {
     166                 :         20 :         internal->min_partial_prefix_len = min_prefix_len;
     167                 :            :     }
     168                 :         20 : }
     169                 :            : 
     170                 :            : Query
     171                 :      64352 : QueryParser::parse_query(const string &query_string, unsigned flags,
     172                 :            :                          const string &default_prefix)
     173                 :            : {
     174                 :      64352 :     internal->stoplist.clear();
     175                 :      64352 :     internal->unstem.clear();
     176                 :      64352 :     internal->errmsg = NULL;
     177                 :            : 
     178         [ +  + ]:      64352 :     if (query_string.empty()) return Query();
     179                 :            : 
     180         [ +  + ]:      64350 :     Query result = internal->parse_query(query_string, flags, default_prefix);
     181 [ +  + ][ +  + ]:      64337 :     if (internal->errmsg && strcmp(internal->errmsg, "parse error") == 0) {
                 [ +  + ]
     182                 :        119 :         flags &= FLAG_CJK_NGRAM;
     183 [ +  - ][ +  - ]:        119 :         result = internal->parse_query(query_string, flags, default_prefix);
     184                 :            :     }
     185                 :            : 
     186 [ +  + ][ +  - ]:      64337 :     if (internal->errmsg) throw Xapian::QueryParserError(internal->errmsg);
         [ +  - ][ +  - ]
     187         [ +  - ]:      64339 :     return result;
     188                 :            : }
     189                 :            : 
     190                 :            : void
     191                 :         53 : QueryParser::add_prefix(const string &field, const string &prefix)
     192                 :            : {
     193                 :            :     Assert(internal.get());
     194                 :         53 :     internal->add_prefix(field, prefix);
     195                 :         52 : }
     196                 :            : 
     197                 :            : void
     198                 :          6 : QueryParser::add_prefix(const string &field, Xapian::FieldProcessor * proc)
     199                 :            : {
     200                 :            :     Assert(internal.get());
     201                 :          6 :     internal->add_prefix(field, proc);
     202                 :          6 : }
     203                 :            : 
     204                 :            : void
     205                 :         26 : QueryParser::add_boolean_prefix(const string &field, const string &prefix,
     206                 :            :                                 const string* grouping)
     207                 :            : {
     208                 :            :     Assert(internal.get());
     209                 :         26 :     internal->add_boolean_prefix(field, prefix, grouping);
     210                 :         24 : }
     211                 :            : 
     212                 :            : void
     213                 :          2 : QueryParser::add_boolean_prefix(const string &field,
     214                 :            :                                 Xapian::FieldProcessor * proc,
     215                 :            :                                 const string* grouping)
     216                 :            : {
     217                 :            :     Assert(internal.get());
     218                 :          2 :     internal->add_boolean_prefix(field, proc, grouping);
     219                 :          2 : }
     220                 :            : 
     221                 :            : TermIterator
     222                 :          3 : QueryParser::stoplist_begin() const
     223                 :            : {
     224                 :          3 :     const list<string> & sl = internal->stoplist;
     225 [ +  - ][ +  - ]:          3 :     return TermIterator(new VectorTermList(sl.begin(), sl.end()));
                 [ +  - ]
     226                 :            : }
     227                 :            : 
     228                 :            : TermIterator
     229                 :          1 : QueryParser::unstem_begin(const string &term) const
     230                 :            : {
     231                 :            :     pair<multimap<string, string>::iterator,
     232                 :          1 :          multimap<string, string>::iterator> range;
     233         [ +  - ]:          1 :     range = internal->unstem.equal_range(term);
     234                 :          1 :     list<string> l;
     235                 :          1 :     multimap<string, string>::iterator & i = range.first;
     236         [ +  + ]:          2 :     while (i != range.second) {
     237         [ +  - ]:          1 :         l.push_back(i->second);
     238                 :          1 :         ++i;
     239                 :            :     }
     240 [ +  - ][ +  - ]:          1 :     return TermIterator(new VectorTermList(l.begin(), l.end()));
                 [ +  - ]
     241                 :            : }
     242                 :            : 
     243                 :            : void
     244                 :         28 : QueryParser::add_rangeprocessor(Xapian::RangeProcessor * range_proc,
     245                 :            :                                 const std::string* grouping)
     246                 :            : {
     247                 :            :     Assert(internal.get());
     248         [ +  - ]:         28 :     internal->rangeprocs.push_back(RangeProc(range_proc, grouping));
     249                 :         28 : }
     250                 :            : 
     251                 :            : string
     252                 :         46 : QueryParser::get_corrected_query_string() const
     253                 :            : {
     254                 :         46 :     return internal->corrected_query;
     255                 :            : }
     256                 :            : 
     257                 :            : string
     258                 :          5 : QueryParser::get_description() const
     259                 :            : {
     260                 :            :     // FIXME : describe better!
     261         [ +  - ]:          5 :     return "Xapian::QueryParser()";
     262                 :            : }

Generated by: LCOV version 1.11