Ignore:
Timestamp:
2013-03-12T14:37:44+13:00 (11 years ago)
Author:
kjdon
Message:

adding reverse sort/sort order in for lucene search results sorting. reorganising code to avoid duplication, added fieldedqueryfilter in the chain of inheritance

File:
1 edited

Legend:

Unmodified
Added
Removed

  • main/trunk/greenstone2/runtime-src/src/colservr/queryfilter.cpp

    r16445 r27064  
    2828
    2929
    30 // translate will return true if successful
    31 bool queryfilterclass::translate (dbclass *db_ptr, text_t& docnum, text_t &trans_OID) {
    32   infodbclass info;
    33 
    34   trans_OID.clear();
    35 
    36   // get the info
    37   if (db_ptr == NULL) return false;
    38   if (!db_ptr->getinfo(docnum, info)) return false;
    39 
    40   // translate
    41   if (info["section"].empty()) return false;
    42 
    43   trans_OID = info["section"];
    44   return true;
    45 }
    46 
    47 
    48 // whether document results are needed
    49 bool queryfilterclass::need_matching_docs (int filterResultOptions) {
    50   return ((filterResultOptions & FROID) || (filterResultOptions & FRranking) ||
    51       (filterResultOptions & FRmetadata));
    52 }
    53 
    54 // whether term information is needed
    55 bool queryfilterclass::need_term_info (int filterResultOptions) {
    56   return ((filterResultOptions & FRtermFreq) || (filterResultOptions & FRmatchTerms));
    57 }
    5830
    5931/////////////////////////////////
    … …  
    6133/////////////////////////////////
    6234
    63 // get the query parameters
    64 void queryfilterclass::parse_query_params (const FilterRequest_t &request,
    65                        vector<queryparamclass> &query_params,
    66                        int &startresults, int &endresults,
    67                        text_t &phrasematch, ostream &logout) {
     35
     36queryfilterclass::queryfilterclass () {
     37  db_ptr = NULL;
     38  textsearchptr = NULL;
     39  maxnumeric = 4;
     40
     41  FilterOption_t filtopt;
     42  filtopt.name = "CombineQuery";
     43  filtopt.type = FilterOption_t::enumeratedt;
     44  filtopt.repeatable = FilterOption_t::onePerQuery;
     45  filtopt.defaultValue = "and";
     46  filtopt.validValues.push_back("and");
     47  filtopt.validValues.push_back("or");
     48  filtopt.validValues.push_back("not");
     49  filterOptions["CombineQuery"] = filtopt;
     50
     51  // -- onePerQuery StartResults   integer
     52  filtopt.clear();
     53  filtopt.name = "StartResults";
     54  filtopt.type = FilterOption_t::integert;
     55  filtopt.repeatable = FilterOption_t::onePerQuery;
     56  filtopt.defaultValue = "1";
     57  filtopt.validValues.push_back("1");
     58  filtopt.validValues.push_back("1000");
     59  filterOptions["StartResults"] = filtopt;
     60
     61  // -- onePerQuery EndResults     integer
     62  filtopt.clear();
     63  filtopt.name = "EndResults";
     64  filtopt.type = FilterOption_t::integert;
     65  filtopt.repeatable = FilterOption_t::onePerQuery;
     66  filtopt.defaultValue = "10";
     67  filtopt.validValues.push_back("-1");
     68  filtopt.validValues.push_back("1000");
     69  filterOptions["EndResults"] = filtopt;
     70
     71  // -- onePerQuery QueryType      enumerated (boolean, ranked)
     72  filtopt.clear();
     73  filtopt.name = "QueryType";
     74  filtopt.type = FilterOption_t::enumeratedt;
     75  filtopt.repeatable = FilterOption_t::onePerQuery;
     76  filtopt.defaultValue = "ranked";
     77  filtopt.validValues.push_back("boolean");
     78  filtopt.validValues.push_back("ranked");
     79  filterOptions["QueryType"] = filtopt;
     80
     81  // -- onePerQuery MatchMode      enumerated (some, all)
     82  filtopt.clear();
     83  filtopt.name = "MatchMode";
     84  filtopt.type = FilterOption_t::enumeratedt;
     85  filtopt.repeatable = FilterOption_t::onePerQuery;
     86  filtopt.defaultValue = "some";
     87  filtopt.validValues.push_back("some");
     88  filtopt.validValues.push_back("all");
     89  filterOptions["MatchMode"] = filtopt;
     90
     91  // -- onePerTerm  Term           string ???
     92  filtopt.clear();
     93  filtopt.name = "Term";
     94  filtopt.type = FilterOption_t::stringt;
     95  filtopt.repeatable = FilterOption_t::onePerTerm;
     96  filtopt.defaultValue = "";
     97  filterOptions["Term"] = filtopt;
     98
     99  // -- onePerTerm  Casefold       boolean
     100  filtopt.clear();
     101  filtopt.name = "Casefold";
     102  filtopt.type = FilterOption_t::booleant;
     103  filtopt.repeatable = FilterOption_t::onePerTerm;
     104  filtopt.defaultValue = "true";
     105  filtopt.validValues.push_back("false");
     106  filtopt.validValues.push_back("true");
     107  filterOptions["Casefold"] = filtopt;
     108
     109  // -- onePerTerm  Stem           boolean
     110  filtopt.clear();
     111  filtopt.name = "Stem";
     112  filtopt.type = FilterOption_t::booleant;
     113  filtopt.repeatable = FilterOption_t::onePerTerm;
     114  filtopt.defaultValue = "false";
     115  filtopt.validValues.push_back("false");
     116  filtopt.validValues.push_back("true");
     117  filterOptions["Stem"] = filtopt;
     118
     119  // -- onePerTerm  AccentFold           boolean
     120  filtopt.clear();
     121  filtopt.name = "AccentFold";
     122  filtopt.type = FilterOption_t::booleant;
     123  filtopt.repeatable = FilterOption_t::onePerTerm;
     124  filtopt.defaultValue = "false";
     125  filtopt.validValues.push_back("false");
     126  filtopt.validValues.push_back("true");
     127  filterOptions["AccentFold"] = filtopt;
     128 
     129  // -- onePerTerm  Index          enumerated
     130  filtopt.clear();
     131  filtopt.name = "Index";
     132  filtopt.type = FilterOption_t::enumeratedt;
     133  filtopt.repeatable = FilterOption_t::onePerTerm;
     134  filtopt.defaultValue = "";
     135  filterOptions["Index"] = filtopt;
     136
     137  // -- onePerTerm  Subcollection  enumerated
     138  filtopt.clear();
     139  filtopt.name = "Subcollection";
     140  filtopt.type = FilterOption_t::enumeratedt;
     141  filtopt.repeatable = FilterOption_t::onePerTerm;
     142  filtopt.defaultValue = "";
     143  filterOptions["Subcollection"] = filtopt;
     144
     145  // -- onePerTerm  Language  enumerated
     146  filtopt.clear();
     147  filtopt.name = "Language";
     148  filtopt.type = FilterOption_t::enumeratedt;
     149  filtopt.repeatable = FilterOption_t::onePerTerm;
     150  filtopt.defaultValue = "";
     151  filterOptions["Language"] = filtopt;
     152
     153  // -- onePerQuery  Maxdocs  integer
     154  filtopt.clear();
     155  filtopt.name = "Maxdocs";
     156  filtopt.type = FilterOption_t::integert;
     157  filtopt.repeatable = FilterOption_t::onePerQuery;
     158  filtopt.defaultValue = "200";
     159  filtopt.validValues.push_back("-1");
     160  filtopt.validValues.push_back("1000");
     161  filterOptions["Maxdocs"] = filtopt;
     162
     163}
     164
     165queryfilterclass::~queryfilterclass () {
     166  // don't delete db_ptr or textsearchptr here, they'll be cleaned up by the source
     167}
     168
     169void queryfilterclass::configure (const text_t &key, const text_tarray &cfgline) {
     170  filterclass::configure (key, cfgline);
     171
     172  if (key == "indexmap") {
     173    indexmap.importmap (cfgline);
     174   
     175    // update the list of indexes in the filter information
     176    text_tarray options;
     177    indexmap.gettoarray (options);
     178    filterOptions["Index"].validValues = options;
     179
     180  } else if (key == "defaultindex") {
     181    indexmap.from2to (cfgline[0], filterOptions["Index"].defaultValue);
     182
     183  } else if (key == "subcollectionmap") {
     184    subcollectionmap.importmap (cfgline);
     185
     186    // update the list of subcollections in the filter information
     187    text_tarray options;
     188    subcollectionmap.gettoarray (options);
     189    filterOptions["Subcollection"].validValues = options;
     190
     191  } else if (key == "defaultsubcollection") {
     192    subcollectionmap.from2to (cfgline[0], filterOptions["Subcollection"].defaultValue);
     193
     194  } else if (key == "languagemap") {
     195    languagemap.importmap (cfgline);
     196
     197    // update the list of languages in the filter information
     198    text_tarray options;
     199    languagemap.gettoarray (options);
     200    filterOptions["Language"].validValues = options;
     201
     202  } else if (key == "defaultlanguage") {
     203    languagemap.from2to (cfgline[0], filterOptions["Language"].defaultValue);
     204  } else if (key == "indexstem") {
     205    indexstem = cfgline[0];
     206  } else if (key == "maxnumeric") {
     207    maxnumeric = cfgline[0].getint();
     208  }
     209 
     210}
     211
     212bool queryfilterclass::init (ostream &logout) {
    68213  outconvertclass text_t2ascii;
    69214
    70   // set defaults for the return parameters
    71   query_params.erase(query_params.begin(), query_params.end());
    72   startresults = filterOptions["StartResults"].defaultValue.getint();
    73   endresults = filterOptions["EndResults"].defaultValue.getint();
    74   phrasematch = filterOptions["PhraseMatch"].defaultValue;
    75 
    76   // set defaults for query parameters
    77   queryparamclass query;
    78   query.combinequery = "or"; // first one must be "or"
     215  if (!filterclass::init(logout)) return false;
     216
     217  if (filterOptions["Index"].defaultValue.empty()) {
     218    // use first index in map as default if no default is set explicitly
     219    text_tarray fromarray;
     220    indexmap.getfromarray(fromarray);
     221    if (fromarray.size()) {
     222      filterOptions["Index"].defaultValue = fromarray[0];
     223    }
     224  }
     225
     226  if (filterOptions["Subcollection"].defaultValue.empty()) {
     227    // use first subcollection in map as default if no default is set explicitly
     228    text_tarray fromarray;
     229    subcollectionmap.getfromarray(fromarray);
     230    if (fromarray.size()) {
     231      filterOptions["Subcollection"].defaultValue = fromarray[0];
     232    }
     233  }
     234
     235  if (filterOptions["Language"].defaultValue.empty()) {
     236    // use first language in map as default if no default is set explicitly
     237    text_tarray fromarray;
     238    languagemap.getfromarray(fromarray);
     239    if (fromarray.size()) {
     240      filterOptions["Language"].defaultValue = fromarray[0];
     241    }
     242  }
     243
     244  if (db_ptr == NULL) {
     245    // most likely a configuration problem
     246    logout << text_t2ascii
     247       << "configuration error: queryfilter contains a null dbclass\n\n";
     248    return false;
     249  }
     250
     251  // get the filename for the database and make sure it exists
     252  if (indexstem.empty()) {
     253    indexstem = collection;
     254  }
     255  db_filename = resolve_db_filename(indexstem,db_ptr->getfileextension());
     256  if (!file_exists(db_filename)) {
     257    logout << text_t2ascii
     258       << "warning: database \"" << db_filename << "\" does not exist\n\n";
     259    //return false;
     260  }
     261
     262  return true;
     263}
     264
     265void queryfilterclass::set_queryparam_defaults(queryparamclass &query ) {
     266 
    79267  query.collection = collection;
    80268  query.index = filterOptions["Index"].defaultValue;
    … …  
    89277  query.maxdocs = filterOptions["Maxdocs"].defaultValue.getint();
    90278  query.level = filterOptions["Level"].defaultValue;
    91   query.filterstring = filterOptions["FilterString"].defaultValue;  // Lucene specific
    92   query.sortfield = filterOptions["SortField"].defaultValue;  // Lucene specific
    93   query.fuzziness = filterOptions["Fuzziness"].defaultValue;  // Lucene specific
    94279  query.maxnumeric = maxnumeric;
     280
     281}
     282
     283bool queryfilterclass::set_queryparam_field(OptionValue_t option, queryparamclass &query) {
     284
     285if (option.name == "QueryType") {
     286      query.search_type = (option.value == "ranked");
     287    } else if (option.name == "MatchMode") {
     288      query.match_mode = (option.value == "all");
     289      if (query.match_mode == 1) query.maxdocs = -1;
     290    } else if (option.name == "Term") {
     291      query.querystring = option.value;
     292    } else if (option.name == "Casefold") {
     293      query.casefolding = (option.value == "true");
     294    } else if (option.name == "Stem") {
     295      query.stemming = (option.value == "true");
     296    } else if (option.name == "AccentFold") {
     297      query.accentfolding = (option.value == "true");
     298    } else if (option.name == "Index"&& option.value !="") {
     299      query.index = option.value;
     300    } else if (option.name == "Subcollection") {
     301      query.subcollection = option.value;
     302    } else if (option.name == "Language") {
     303      query.language = option.value;
     304    } else if (option.name == "Maxdocs") {
     305      query.maxdocs = option.value.getint();
     306    // } else if (option.name == "PhraseMatch") {
     307    //   phrasematch = option.value;
     308    } else if (option.name == "Level") {
     309      query.level = option.value;
     310    } else if (option.name == "FilterString") {
     311      query.filterstring = option.value;
     312    } else if (option.name == "SortField") {
     313      query.sortfield = option.value;
     314    } else if (option.name == "SortOrder") {
     315      query.sortorder = (option.value == "descending");
     316    } else if (option.name == "Fuzziness") {
     317      query.fuzziness = option.value;
     318 }
     319}
     320// get the query parameters
     321void queryfilterclass::parse_query_params (const FilterRequest_t &request,
     322                       vector<queryparamclass> &query_params,
     323                       int &startresults, int &endresults,
     324                       ostream &logout) {
     325  outconvertclass text_t2ascii;
     326
     327  // set defaults for the return parameters
     328  query_params.erase(query_params.begin(), query_params.end());
     329  startresults = filterOptions["StartResults"].defaultValue.getint();
     330  endresults = filterOptions["EndResults"].defaultValue.getint();
     331
     332  // set defaults for query parameters
     333  queryparamclass query;
     334  query.combinequery = "or"; // first one must be "or"
     335  set_queryparam_defaults(query);
    95336  OptionValue_tarray::const_iterator options_here = request.filterOptions.begin();
    96337  OptionValue_tarray::const_iterator options_end = request.filterOptions.end();
    … …  
    108349
    109350      // set defaults for query parameters
    110       query.collection = collection;
    111       query.index = filterOptions["Index"].defaultValue;
    112       query.subcollection = filterOptions["Subcollection"].defaultValue;
    113       query.language = filterOptions["Language"].defaultValue;
    114       query.querystring.clear();
    115       query.search_type = (filterOptions["QueryType"].defaultValue == "ranked");
    116       query.match_mode = (filterOptions["MatchMode"].defaultValue == "all");
    117       query.casefolding = (filterOptions["Casefold"].defaultValue == "true");
    118       query.stemming = (filterOptions["Stem"].defaultValue == "true");
    119       query.accentfolding = (filterOptions["AccentFold"].defaultValue == "true");
    120       query.level = filterOptions["Level"].defaultValue;
    121       query.filterstring = filterOptions["FilterString"].defaultValue;  // Lucene specific
    122       query.sortfield = filterOptions["SortField"].defaultValue;  // Lucene specific
    123       query.fuzziness = filterOptions["Fuzziness"].defaultValue;  // Lucene specific
    124       query.maxnumeric = maxnumeric;
     351      set_queryparam_defaults(query);
     352
    125353      // "all", needed when combining queries where the document results are needed
    126354      if (need_matching_docs (request.filterResultOptions)) query.maxdocs = -1;
    127       else query.maxdocs = filterOptions["Maxdocs"].defaultValue.getint();
    128355     
    129356    } else if ((*options_here).name == "StartResults") {
    … …  
    131358    } else if ((*options_here).name == "EndResults") {
    132359      endresults = (*options_here).value.getint();
    133     } else if ((*options_here).name == "QueryType") {
    134       query.search_type = ((*options_here).value == "ranked");
    135     } else if ((*options_here).name == "MatchMode") {
    136       query.match_mode = ((*options_here).value == "all");
    137       if (query.match_mode == 1) query.maxdocs = -1;
    138     } else if ((*options_here).name == "Term") {
    139       query.querystring = (*options_here).value;
    140     } else if ((*options_here).name == "Casefold") {
    141       query.casefolding = ((*options_here).value == "true");
    142     } else if ((*options_here).name == "Stem") {
    143       query.stemming = ((*options_here).value == "true");
    144     } else if ((*options_here).name == "AccentFold") {
    145       query.accentfolding = ((*options_here).value == "true");
    146     } else if ((*options_here).name == "Index"&& (*options_here).value !="") {
    147       query.index = (*options_here).value;
    148     } else if ((*options_here).name == "Subcollection") {
    149       query.subcollection = (*options_here).value;
    150     } else if ((*options_here).name == "Language") {
    151       query.language = (*options_here).value;
    152     } else if ((*options_here).name == "Maxdocs") {
    153       query.maxdocs = (*options_here).value.getint();
    154     } else if ((*options_here).name == "PhraseMatch") {
    155       phrasematch = (*options_here).value;
    156     } else if ((*options_here).name == "Level") {
    157       query.level = (*options_here).value;
    158     } else if ((*options_here).name == "FilterString") {
    159       query.filterstring = (*options_here).value;
    160     } else if ((*options_here).name == "SortField") {
    161       query.sortfield = (*options_here).value;
    162     } else if ((*options_here).name == "Fuzziness") {
    163       query.fuzziness = (*options_here).value;
    164     } else {
     360    } else if (!set_queryparam_field(*options_here, query)) {
    165361      logout << text_t2ascii
    166362         << "warning: unknown queryfilter option \""
    … …  
    183379
    184380
    185 
    186 queryfilterclass::queryfilterclass () {
    187   db_ptr = NULL;
    188   textsearchptr = NULL;
    189   maxnumeric = 4;
    190 
    191   FilterOption_t filtopt;
    192   filtopt.name = "CombineQuery";
    193   filtopt.type = FilterOption_t::enumeratedt;
    194   filtopt.repeatable = FilterOption_t::onePerQuery;
    195   filtopt.defaultValue = "and";
    196   filtopt.validValues.push_back("and");
    197   filtopt.validValues.push_back("or");
    198   filtopt.validValues.push_back("not");
    199   filterOptions["CombineQuery"] = filtopt;
    200 
    201   // -- onePerQuery StartResults   integer
    202   filtopt.clear();
    203   filtopt.name = "StartResults";
    204   filtopt.type = FilterOption_t::integert;
    205   filtopt.repeatable = FilterOption_t::onePerQuery;
    206   filtopt.defaultValue = "1";
    207   filtopt.validValues.push_back("1");
    208   filtopt.validValues.push_back("1000");
    209   filterOptions["StartResults"] = filtopt;
    210 
    211   // -- onePerQuery EndResults     integer
    212   filtopt.clear();
    213   filtopt.name = "EndResults";
    214   filtopt.type = FilterOption_t::integert;
    215   filtopt.repeatable = FilterOption_t::onePerQuery;
    216   filtopt.defaultValue = "10";
    217   filtopt.validValues.push_back("-1");
    218   filtopt.validValues.push_back("1000");
    219   filterOptions["EndResults"] = filtopt;
    220 
    221   // -- onePerQuery QueryType      enumerated (boolean, ranked)
    222   filtopt.clear();
    223   filtopt.name = "QueryType";
    224   filtopt.type = FilterOption_t::enumeratedt;
    225   filtopt.repeatable = FilterOption_t::onePerQuery;
    226   filtopt.defaultValue = "ranked";
    227   filtopt.validValues.push_back("boolean");
    228   filtopt.validValues.push_back("ranked");
    229   filterOptions["QueryType"] = filtopt;
    230 
    231   // -- onePerQuery MatchMode      enumerated (some, all)
    232   filtopt.clear();
    233   filtopt.name = "MatchMode";
    234   filtopt.type = FilterOption_t::enumeratedt;
    235   filtopt.repeatable = FilterOption_t::onePerQuery;
    236   filtopt.defaultValue = "some";
    237   filtopt.validValues.push_back("some");
    238   filtopt.validValues.push_back("all");
    239   filterOptions["MatchMode"] = filtopt;
    240 
    241   // -- onePerTerm  Term           string ???
    242   filtopt.clear();
    243   filtopt.name = "Term";
    244   filtopt.type = FilterOption_t::stringt;
    245   filtopt.repeatable = FilterOption_t::onePerTerm;
    246   filtopt.defaultValue = "";
    247   filterOptions["Term"] = filtopt;
    248 
    249   // -- onePerTerm  Casefold       boolean
    250   filtopt.clear();
    251   filtopt.name = "Casefold";
    252   filtopt.type = FilterOption_t::booleant;
    253   filtopt.repeatable = FilterOption_t::onePerTerm;
    254   filtopt.defaultValue = "true";
    255   filtopt.validValues.push_back("false");
    256   filtopt.validValues.push_back("true");
    257   filterOptions["Casefold"] = filtopt;
    258 
    259   // -- onePerTerm  Stem           boolean
    260   filtopt.clear();
    261   filtopt.name = "Stem";
    262   filtopt.type = FilterOption_t::booleant;
    263   filtopt.repeatable = FilterOption_t::onePerTerm;
    264   filtopt.defaultValue = "false";
    265   filtopt.validValues.push_back("false");
    266   filtopt.validValues.push_back("true");
    267   filterOptions["Stem"] = filtopt;
    268 
    269   // -- onePerTerm  AccentFold           boolean
    270   filtopt.clear();
    271   filtopt.name = "AccentFold";
    272   filtopt.type = FilterOption_t::booleant;
    273   filtopt.repeatable = FilterOption_t::onePerTerm;
    274   filtopt.defaultValue = "false";
    275   filtopt.validValues.push_back("false");
    276   filtopt.validValues.push_back("true");
    277   filterOptions["AccentFold"] = filtopt;
    278  
    279   // -- onePerTerm  Index          enumerated
    280   filtopt.clear();
    281   filtopt.name = "Index";
    282   filtopt.type = FilterOption_t::enumeratedt;
    283   filtopt.repeatable = FilterOption_t::onePerTerm;
    284   filtopt.defaultValue = "";
    285   filterOptions["Index"] = filtopt;
    286 
    287   // -- onePerTerm  Subcollection  enumerated
    288   filtopt.clear();
    289   filtopt.name = "Subcollection";
    290   filtopt.type = FilterOption_t::enumeratedt;
    291   filtopt.repeatable = FilterOption_t::onePerTerm;
    292   filtopt.defaultValue = "";
    293   filterOptions["Subcollection"] = filtopt;
    294 
    295   // -- onePerTerm  Language  enumerated
    296   filtopt.clear();
    297   filtopt.name = "Language";
    298   filtopt.type = FilterOption_t::enumeratedt;
    299   filtopt.repeatable = FilterOption_t::onePerTerm;
    300   filtopt.defaultValue = "";
    301   filterOptions["Language"] = filtopt;
    302 
    303   // -- onePerQuery  Maxdocs  integer
    304   filtopt.clear();
    305   filtopt.name = "Maxdocs";
    306   filtopt.type = FilterOption_t::integert;
    307   filtopt.repeatable = FilterOption_t::onePerQuery;
    308   filtopt.defaultValue = "200";
    309   filtopt.validValues.push_back("-1");
    310   filtopt.validValues.push_back("1000");
    311   filterOptions["Maxdocs"] = filtopt;
    312 
    313   // -- onePerQuery  PhraseMatch  enumerated
    314   filtopt.clear();
    315   filtopt.name = "PhraseMatch";
    316   filtopt.type = FilterOption_t::enumeratedt;
    317   filtopt.repeatable = FilterOption_t::onePerQuery;
    318   filtopt.defaultValue = "some_phrases";
    319   filtopt.validValues.push_back ("all_phrases");
    320   filtopt.validValues.push_back ("some_phrases");
    321   filtopt.validValues.push_back ("all_docs");
    322   filterOptions["PhraseMatch"] = filtopt;
    323 }
    324 
    325 queryfilterclass::~queryfilterclass () {
    326   // don't delete db_ptr or textsearchptr here, they'll be cleaned up by the source
    327 }
    328 
    329 void queryfilterclass::configure (const text_t &key, const text_tarray &cfgline) {
    330   filterclass::configure (key, cfgline);
    331 
    332   if (key == "indexmap") {
    333     indexmap.importmap (cfgline);
    334    
    335     // update the list of indexes in the filter information
    336     text_tarray options;
    337     indexmap.gettoarray (options);
    338     filterOptions["Index"].validValues = options;
    339 
    340   } else if (key == "defaultindex") {
    341     indexmap.from2to (cfgline[0], filterOptions["Index"].defaultValue);
    342 
    343   } else if (key == "subcollectionmap") {
    344     subcollectionmap.importmap (cfgline);
    345 
    346     // update the list of subcollections in the filter information
    347     text_tarray options;
    348     subcollectionmap.gettoarray (options);
    349     filterOptions["Subcollection"].validValues = options;
    350 
    351   } else if (key == "defaultsubcollection") {
    352     subcollectionmap.from2to (cfgline[0], filterOptions["Subcollection"].defaultValue);
    353 
    354   } else if (key == "languagemap") {
    355     languagemap.importmap (cfgline);
    356 
    357     // update the list of languages in the filter information
    358     text_tarray options;
    359     languagemap.gettoarray (options);
    360     filterOptions["Language"].validValues = options;
    361 
    362   } else if (key == "defaultlanguage") {
    363     languagemap.from2to (cfgline[0], filterOptions["Language"].defaultValue);
    364   } else if (key == "indexstem") {
    365     indexstem = cfgline[0];
    366   } else if (key == "maxnumeric") {
    367     maxnumeric = cfgline[0].getint();
    368   }
    369  
    370 }
    371 
    372 bool queryfilterclass::init (ostream &logout) {
    373   outconvertclass text_t2ascii;
    374 
    375   if (!filterclass::init(logout)) return false;
    376 
    377   if (filterOptions["Index"].defaultValue.empty()) {
    378     // use first index in map as default if no default is set explicitly
    379     text_tarray fromarray;
    380     indexmap.getfromarray(fromarray);
    381     if (fromarray.size()) {
    382       filterOptions["Index"].defaultValue = fromarray[0];
    383     }
    384   }
    385 
    386   if (filterOptions["Subcollection"].defaultValue.empty()) {
    387     // use first subcollection in map as default if no default is set explicitly
    388     text_tarray fromarray;
    389     subcollectionmap.getfromarray(fromarray);
    390     if (fromarray.size()) {
    391       filterOptions["Subcollection"].defaultValue = fromarray[0];
    392     }
    393   }
    394 
    395   if (filterOptions["Language"].defaultValue.empty()) {
    396     // use first language in map as default if no default is set explicitly
    397     text_tarray fromarray;
    398     languagemap.getfromarray(fromarray);
    399     if (fromarray.size()) {
    400       filterOptions["Language"].defaultValue = fromarray[0];
    401     }
    402   }
    403 
    404   if (db_ptr == NULL) {
    405     // most likely a configuration problem
    406     logout << text_t2ascii
    407        << "configuration error: queryfilter contains a null dbclass\n\n";
    408     return false;
    409   }
    410 
    411   // get the filename for the database and make sure it exists
    412   if (indexstem.empty()) {
    413     indexstem = collection;
    414   }
    415   db_filename = resolve_db_filename(indexstem,db_ptr->getfileextension());
    416   if (!file_exists(db_filename)) {
    417     logout << text_t2ascii
    418        << "warning: database \"" << db_filename << "\" does not exist\n\n";
    419     //return false;
    420   }
    421 
     381// translate will return true if successful
     382bool queryfilterclass::translate (dbclass *db_ptr, text_t& docnum, text_t &trans_OID) {
     383  infodbclass info;
     384
     385  trans_OID.clear();
     386
     387  // get the info
     388  if (db_ptr == NULL) return false;
     389  if (!db_ptr->getinfo(docnum, info)) return false;
     390
     391  // translate
     392  if (info["section"].empty()) return false;
     393
     394  trans_OID = info["section"];
    422395  return true;
    423396}
    424397
     398
     399// whether document results are needed
     400bool queryfilterclass::need_matching_docs (int filterResultOptions) {
     401  return ((filterResultOptions & FROID) || (filterResultOptions & FRranking) ||
     402      (filterResultOptions & FRmetadata));
     403}
     404
     405// whether term information is needed
     406bool queryfilterclass::need_term_info (int filterResultOptions) {
     407  return ((filterResultOptions & FRtermFreq) || (filterResultOptions & FRmatchTerms));
     408}
Note: See TracChangeset for help on using the changeset viewer.