Changeset 351 for trunk/gsdl/src/colservr/queryinfo.cpp

Timestamp:

1999-07-07T18:19:47+12:00 (25 years ago)

Author:

rjmcnab

Message:

Added ability to combine two or more independant queries.

File:

• trunk/gsdl/src/colservr/queryinfo.cpp (modified) (12 diffs)

trunk/gsdl/src/colservr/queryinfo.cpp

@@ -12 +12 @@
 /*
    $Log$
+   Revision 1.7  1999/07/07 06:19:47  rjmcnab
+   Added ability to combine two or more independant queries.
+
    Revision 1.6  1999/07/01 09:29:21  rjmcnab
    Changes for better reporting of number documents which match a query. Changes
@@ -44 +47 @@
 // query parameters
 
-queryparamclass &queryparamclass::operator=(const queryparamclass &q)
-{
+queryparamclass::queryparamclass () {
+  clear ();
+}
+
+void queryparamclass::clear () {
+  combinequery.clear();
+  collection.clear();
+  index.clear();
+  subcollection.clear();
+  language.clear();
+  querystring.clear();
+  search_type = 0; // 0 = boolean, 1 = ranked
+  casefolding = 0;
+  stemming = 0;
+  maxdocs = -1;    // all
+}
+
+
+queryparamclass &queryparamclass::operator=(const queryparamclass &q) {
+  combinequery = q.combinequery;
   collection = q.collection;
-  search_index = q.search_index;
+  index = q.index;
+  subcollection = q.subcollection;
+  language = q.language;
   querystring = q.querystring;
   search_type = q.search_type;
@@ -58 +81 @@
 
 
-bool operator==(const queryparamclass &x, const queryparamclass &y)
-{
-  return ((x.collection == y.collection) &&
-      (x.search_index == y.search_index) &&
+bool operator==(const queryparamclass &x, const queryparamclass &y) {
+  return ((x.combinequery == y.combinequery) &&
+      (x.collection == y.collection) &&
+      (x.index == y.index) &&
+      (x.subcollection == y.subcollection) &&
+      (x.language == y.language) &&
       (x.querystring == y.querystring) &&
       (x.search_type == y.search_type) &&
@@ -69 +94 @@
 }
 
-bool operator!=(const queryparamclass &x, const queryparamclass &y)
-{
+bool operator!=(const queryparamclass &x, const queryparamclass &y) {
   return !(x == y);
 }
 
 
-ostream &operator<< (ostream &outs, queryparamclass &q)
-{
+ostream &operator<< (ostream &outs, queryparamclass &q) {
   outconvertclass text_t2ascii;
 
   outs << "*** queryparamclass\n";
+  outs << text_t2ascii << " combinequery = \"" << q.combinequery << "\"\n";
   outs << text_t2ascii << " collection = \"" << q.collection << "\"\n";
-  outs << text_t2ascii << " search_index = \"" << q.search_index << "\"\n";
+  outs << text_t2ascii << " index = \"" << q.index << "\"\n";
+  outs << text_t2ascii << " subcollection = \"" << q.subcollection << "\"\n";
+  outs << text_t2ascii << " language = \"" << q.language << "\"\n";
   outs << text_t2ascii << " querystring = \"" << q.querystring << "\"\n";
   outs << " search_type = \"" << q.search_type << "\"\n";
@@ -97 +123 @@
 // term frequencies
 
-termfreqclass &termfreqclass::operator=(const termfreqclass &t) 
-{
+termfreqclass::termfreqclass () {
+  clear();
+}
+
+void termfreqclass::clear() {
+  termstr.clear();
+  termstemstr.clear();
+  utf8equivterms.erase(utf8equivterms.begin(), utf8equivterms.end());
+  termfreq = 0;
+}
+
+termfreqclass &termfreqclass::operator=(const termfreqclass &t)  {
   termstr = t.termstr;
   termstemstr = t.termstemstr;
@@ -107 +143 @@
 }
     
-bool operator==(const termfreqclass &x, const termfreqclass &y)
-{
+bool operator==(const termfreqclass &x, const termfreqclass &y) {
   return ((x.termstr == y.termstr) &&
       (x.termstemstr == y.termstemstr) &&
@@ -114 +149 @@
 }
 
-bool operator!=(const termfreqclass &x, const termfreqclass &y)
-{
+bool operator!=(const termfreqclass &x, const termfreqclass &y) {
   return !(x == y);
 }
 
 // ordered by termfreq and then by termstr
-bool operator<(const termfreqclass &x, const termfreqclass &y)
-{
+bool operator<(const termfreqclass &x, const termfreqclass &y) {
   return ((x.termfreq < y.termfreq) ||
       ((x.termfreq == y.termfreq) && (x.termstemstr < y.termstemstr)) ||
@@ -127 +160 @@
 }
 
-bool operator>(const termfreqclass &x, const termfreqclass &y)
-{
+bool operator>(const termfreqclass &x, const termfreqclass &y) {
   return ((x.termfreq > y.termfreq) ||
       ((x.termfreq == y.termfreq) && (x.termstemstr > y.termstemstr)) ||
@@ -135 +167 @@
 
 // stream output for debugging purposes
-ostream &operator<< (ostream &outs, termfreqclass &t)
-{
+ostream &operator<< (ostream &outs, termfreqclass &t) {
   outconvertclass text_t2ascii;
 
@@ -150 +181 @@
 // one query result
 
+docresultclass::docresultclass() {
+  clear ();
+}
+
+void docresultclass::clear () {
+  docnum=-1;
+  docweight=0.0;
+  num_query_terms_matched=0;
+  num_phrase_match=0;
+}
+
+// merges two result classes relating to a single docnum
+docresultclass &docresultclass::combine(const docresultclass &d) {
+  docweight += d.docweight; // budget!
+  num_query_terms_matched += d.num_query_terms_matched;
+  num_phrase_match += d.num_phrase_match;
+
+  return *this;
+}
+
+docresultclass &docresultclass::operator=(const docresultclass &d) {
+  docnum = d.docnum;
+  docweight = d.docweight;
+  num_query_terms_matched = d.num_query_terms_matched;
+  num_phrase_match = d.num_phrase_match;
+
+  return *this;
+}
+
+
 // stream output for debugging purposes
-ostream &operator<< (ostream &outs, docresultclass &a)
-{
+ostream &operator<< (ostream &outs, docresultclass &a) {
   outs << " d:" << a.docnum << " w:" << a.docweight << "\n";
   return outs;
 }
+
+
+
+// many document results
+
+docresultsclass::docresultsclass () {
+  clear ();
+}
+
+void docresultsclass::clear () {
+  docset.erase(docset.begin(), docset.end());
+  docorder.erase(docorder.begin(), docorder.end());
+}
+
+void docresultsclass::docnum_order() {
+  docorder.erase(docorder.begin(), docorder.end());
+  
+  docresultmap::iterator here = docset.begin();
+  docresultmap::iterator end = docset.end();
+  while (here != end) {
+    docorder.push_back ((*here).first);
+    here++;
+  }
+}
+
+void docresultsclass::combine_and (const docresultsclass &d) {
+  docorder.erase(docorder.begin(), docorder.end());
+
+  // put the resulting set in tempresults
+  docresultmap tempresults;
+  
+  docresultmap::const_iterator d_here = d.docset.begin();
+  docresultmap::const_iterator d_end = d.docset.end();
+  docresultmap::iterator found = docset.end();
+  while (d_here != d_end) {
+    found = docset.find((*d_here).first);
+    if (found != docset.end()) {
+      (*found).second.combine ((*d_here).second);
+      tempresults[(*found).first] = (*found).second;
+    }
+    d_here++;
+  }
+
+  // then copy it back to docset
+  docset = tempresults;
+}
+
+void docresultsclass::combine_or (const docresultsclass &d) {
+  docorder.erase(docorder.begin(), docorder.end());
+    
+  docresultmap::const_iterator d_here = d.docset.begin();
+  docresultmap::const_iterator d_end = d.docset.end();
+  docresultmap::iterator found = docset.end();
+  while (d_here != d_end) {
+    found = docset.find((*d_here).first);
+    if (found != docset.end()) {
+      (*found).second.combine ((*d_here).second);
+    } else {
+      docset[(*d_here).first] = (*d_here).second;
+    }
+    d_here++;
+  }
+}
+
+void docresultsclass::combine_not (const docresultsclass &d) {
+  docorder.erase(docorder.begin(), docorder.end());
+
+ docresultmap::const_iterator d_here = d.docset.begin();
+ docresultmap::const_iterator d_end = d.docset.end();
+ docresultmap::iterator found = docset.end();
+ while (d_here != d_end) {
+   found = docset.find((*d_here).first);
+   if (found != docset.end()) docset.erase (found);
+   d_here++;
+ }
+}
+
+docresultsclass &docresultsclass::operator=(const docresultsclass &d) {
+  docset = d.docset;
+  docorder = d.docorder;
+
+  return *this;
+}
+
 
 
@@ -167 +311 @@
   postprocessed = false;
 
-  docs.erase(docs.begin(),docs.end());
+  docs.clear();
   orgterms.erase(orgterms.begin(),orgterms.end());
   terms.erase(terms.begin(),terms.end());
@@ -186 +330 @@
 
 void queryresultsclass::sortuniqqueryterms() {
-  terms = orgterms;
-
-  // sort the terms
+  vector<termfreqclass> tempterms = orgterms;
+  text_tset seenterms;
+  terms.clear();
+
+  // sort the terms to get the frequencies in ascending order
+  sort (tempterms.begin(), tempterms.end());
+
+  // insert first occurance of each term (maximum)
+  vector<termfreqclass>::reverse_iterator here = tempterms.rbegin();
+  vector<termfreqclass>::reverse_iterator end = tempterms.rend();
+  while (here != end) {
+    if (seenterms.find((*here).termstr) == seenterms.end()) {
+      // the termstemstr and utf8equivterms might be different for
+      // different occurances of the term
+      (*here).termstemstr.clear();
+      (*here).utf8equivterms.erase((*here).utf8equivterms.begin(),
+                   (*here).utf8equivterms.end());
+      terms.push_back(*here);
+      seenterms.insert((*here).termstr);
+    }
+    here++;
+  }
+
+  // now re-sort in ascending order
   sort (terms.begin(), terms.end());
-
-  // and then unique them
-  vector<termfreqclass>::iterator new_end = unique (terms.begin(), terms.end());
-  terms.erase(new_end, terms.end());
 }
 
 
 // stream output for debugging purposes
-ostream &operator<< (ostream &outs, queryresultsclass &q)
-{
+ostream &operator<< (ostream &outs, queryresultsclass &q) {
   outs << "*** queryresultsclass\n";
   outs << "docs\n";
 
-  vector<docresultclass>::iterator docshere = q.docs.begin();
-  vector<docresultclass>::iterator docsend = q.docs.end();
+  docresultmap::iterator docshere = q.docs.docset.begin();
+  docresultmap::iterator docsend = q.docs.docset.end();
   while (docshere != docsend) {
-    outs << (*docshere);
+    outs << (*docshere).second;
     docshere++;
   }