comparison query.cpp @ 458:913a95f06998 api-inversion

Start using the query state structure.

Actually using it means moving it around in the source code a little
bit, thanks to entanglements.  It'll all be alright on the night.  Now
the accumulator, allowed_keys and exact_evaluation_queue are all part of
the query state, and can therefore be passed around with minimal effort
(and deleted in the appropriate place).

Now a whole bunch of static methods (the callbacks, basically) in
index.cpp can be rewritten as plain old C functions.  The callbacks need
both an adb_t and a query state structure to function (the adb_t to get
at things like lsh_n_point_bits and the track->key table; the qstate to
get at the accumulator and allowed_keys list).

Rearrange audioDB::query a little bit, and mark the beginning and the
end of the putative audiodb_query_spec() API function implementation.

       if(!(qspec.refine.flags & ADB_REFINE_RADIUS)) {
         reporter = new trackAveragingReporter< std::less< NNresult > >(pointNN, trackNN, dbH->numFiles);
       } else if (index_exists(adb->path, qspec.refine.radius, qspec.qid.sequence_length)) {
 	char* indexName = index_get_name(adb->path, qspec.refine.radius, qspec.qid.sequence_length);
 	lsh = index_allocate(indexName, false);
-	reporter = new trackSequenceQueryRadReporter(trackNN, index_to_trackID(lsh->get_maxp(), lsh_n_point_bits)+1);
+	reporter = new trackSequenceQueryRadReporter(trackNN, audiodb_index_to_track_id(lsh->get_maxp(), audiodb_lsh_n_point_bits(adb))+1);
 	delete[] indexName;
       } else {
 	reporter = new trackSequenceQueryRadReporter(trackNN, dbH->numFiles);
       }
       break;

       if(!(qspec.refine.flags & ADB_REFINE_RADIUS)) {
         reporter = new trackSequenceQueryNNReporter< std::less < NNresult > >(pointNN, trackNN, dbH->numFiles);
       } else if (index_exists(adb->path, qspec.refine.radius, qspec.qid.sequence_length)){
 	char* indexName = index_get_name(adb->path, qspec.refine.radius, qspec.qid.sequence_length);
 	lsh = index_allocate(indexName, false);
-	reporter = new trackSequenceQueryRadNNReporter(pointNN,trackNN, index_to_trackID(lsh->get_maxp(), lsh_n_point_bits)+1);
+	reporter = new trackSequenceQueryRadNNReporter(pointNN,trackNN, audiodb_index_to_track_id(lsh->get_maxp(), audiodb_lsh_n_point_bits(adb))+1);
 	delete[] indexName;
       } else {
 	reporter = new trackSequenceQueryRadNNReporter(pointNN,trackNN, dbH->numFiles);
       }
       break;

     break;
   default:
     error("unrecognized queryType");
   }
 
-  // keyKeyPos requires dbH to be initialized
-  if(query_from_key && (!key || (query_from_key_index = audiodb_key_index(adb, key)) == (uint32_t) -1)) 
-    error("Query key not found", key);  
+  /* Somewhere around here is where the implementation of
+   * audiodb_query_spec() starts. */
+
+  adb_qstate_internal_t qstate;
+  qstate.allowed_keys = new std::set<std::string>;
+  if(qspec.refine.flags & ADB_REFINE_INCLUDE_KEYLIST) {
+    for(unsigned int k = 0; k < qspec.refine.include.nkeys; k++) {
+      qstate.allowed_keys->insert(qspec.refine.include.keys[k]);
+    }
+  } else {
+    for(unsigned int k = 0; k < adb->header->numFiles; k++) {
+      qstate.allowed_keys->insert((*adb->keys)[k]);
+    }
+  }
+  if(qspec.refine.flags & ADB_REFINE_EXCLUDE_KEYLIST) {
+    for(unsigned int k = 0; k < qspec.refine.exclude.nkeys; k++) {
+      qstate.allowed_keys->erase(qspec.refine.exclude.keys[k]);
+    }
+  }
 
   switch(qspec.params.distance) {
   case ADB_DISTANCE_DOT_PRODUCT:
     switch(qspec.params.accumulation) {
     case ADB_ACCUMULATION_DB:
-      accumulator = new DBAccumulator<adb_result_dist_gt>(qspec.params.npoints);
+      qstate.accumulator = new DBAccumulator<adb_result_dist_gt>(qspec.params.npoints);
       break;
     case ADB_ACCUMULATION_PER_TRACK:
-      accumulator = new PerTrackAccumulator<adb_result_dist_gt>(qspec.params.npoints, qspec.params.ntracks);
+      qstate.accumulator = new PerTrackAccumulator<adb_result_dist_gt>(qspec.params.npoints, qspec.params.ntracks);
       break;
     case ADB_ACCUMULATION_ONE_TO_ONE:
-      accumulator = new NearestAccumulator<adb_result_dist_gt>();
+      qstate.accumulator = new NearestAccumulator<adb_result_dist_gt>();
       break;
     default:
       error("unknown accumulation");
     }
     break;
   case ADB_DISTANCE_EUCLIDEAN_NORMED:
   case ADB_DISTANCE_EUCLIDEAN:
     switch(qspec.params.accumulation) {
     case ADB_ACCUMULATION_DB:
-      accumulator = new DBAccumulator<adb_result_dist_lt>(qspec.params.npoints);
+      qstate.accumulator = new DBAccumulator<adb_result_dist_lt>(qspec.params.npoints);
       break;
     case ADB_ACCUMULATION_PER_TRACK:
-      accumulator = new PerTrackAccumulator<adb_result_dist_lt>(qspec.params.npoints, qspec.params.ntracks);
+      qstate.accumulator = new PerTrackAccumulator<adb_result_dist_lt>(qspec.params.npoints, qspec.params.ntracks);
       break;
     case ADB_ACCUMULATION_ONE_TO_ONE:
-      accumulator = new NearestAccumulator<adb_result_dist_lt>();
+      qstate.accumulator = new NearestAccumulator<adb_result_dist_lt>();
       break;
     default:
       error("unknown accumulation");
     }
     break;

   }
   
   // Test for index (again) here
   if((qspec.refine.flags & ADB_REFINE_RADIUS) && index_exists(adb->path, qspec.refine.radius, qspec.qid.sequence_length)){ 
     VERB_LOG(1, "Calling indexed query on database %s, radius=%f, sequence_length=%d\n", adb->path, qspec.refine.radius, qspec.qid.sequence_length);
-    index_query_loop(adb, &qspec);
+    index_query_loop(adb, &qspec, &qstate);
   }
   else{
     VERB_LOG(1, "Calling brute-force query on database %s\n", dbName);
-    if(query_loop(adb, &qspec)) {
+    if(query_loop(adb, &qspec, &qstate)) {
       error("query_loop failed");
     }
   }
 
-  adb_query_results_t *rs = accumulator->get_points();
+  adb_query_results_t *rs = qstate.accumulator->get_points();
+
+  delete qstate.accumulator;
+  delete qstate.allowed_keys;
+
+  /* End of audiodb_query_spec() function */
+
   for(unsigned int k = 0; k < rs->nresults; k++) {
     adb_result_t r = rs->results[k];
     reporter->add_point(audiodb_key_index(adb, r.key), r.qpos, r.ipos, r.dist);
   }
 

 // A reporter has been allocated
 //
 // Postconditions:
 // reporter contains the points and distances that meet the reporter constraints 
 
-void audioDB::query_loop_points(adb_t *adb, adb_query_spec_t *spec, double* query, adb_qpointers_internal_t *qpointers) {
+void audioDB::query_loop_points(adb_t *adb, adb_query_spec_t *spec, adb_qstate_internal_t *qstate, double *query, adb_qpointers_internal_t *qpointers) {
   adb_qpointers_internal_t dbpointers = {0};
 
   uint32_t sequence_length = spec->qid.sequence_length;
   bool power_refine = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
 
-  if(exact_evaluation_queue->size() == 0) {
+  if(qstate->exact_evaluation_queue->size() == 0) {
     return;
   }
 
   // Compute database info.  FIXME: we more than likely don't need
   // very much of the database so write a new function to build these

   size_t data_buffer_size = 0;
   double *data_buffer = 0;
   Uns32T trackOffset = 0;
   Uns32T trackIndexOffset = 0;
   Uns32T currentTrack = 0x80000000; // Initialize with a value outside of track index range
-  Uns32T npairs = exact_evaluation_queue->size();
+  Uns32T npairs = qstate->exact_evaluation_queue->size();
   while(npairs--){
-    PointPair pp = exact_evaluation_queue->top();
+    PointPair pp = qstate->exact_evaluation_queue->top();
     // Large ADB track data must be loaded here for sPower
     if(adb->header->flags & O2_FLAG_LARGE_ADB) {
       trackOffset=0;
       trackIndexOffset=0;
       if(currentTrack!=pp.trackID){

         adb_result_t r;
         r.key = (*adb->keys)[pp.trackID].c_str();
         r.dist = dist;
         r.qpos = pp.qpos;
         r.ipos = pp.spos;
-        accumulator->add_point(&r);
-      }
-    }
-    exact_evaluation_queue->pop();
+        qstate->accumulator->add_point(&r);
+      }
+    }
+    qstate->exact_evaluation_queue->pop();
   }
   // Cleanup
   SAFE_DELETE_ARRAY(dbpointers.l2norm_data);
   SAFE_DELETE_ARRAY(dbpointers.power_data);
   SAFE_DELETE_ARRAY(dbpointers.mean_duration);
-}
-
-int audioDB::query_loop(adb_t *adb, adb_query_spec_t *spec) {
+  delete qstate->exact_evaluation_queue;
+}
+
+int audioDB::query_loop(adb_t *adb, adb_query_spec_t *spec, adb_qstate_internal_t *qstate) {
   
   double *query, *query_data;
   adb_qpointers_internal_t qpointers = {0}, dbpointers = {0};
 
   bool power_refine = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
-
-  std::set<std::string> keys;
-  if(spec->refine.flags & ADB_REFINE_INCLUDE_KEYLIST) {
-    for(unsigned int k = 0; k < spec->refine.include.nkeys; k++) {
-      keys.insert(spec->refine.include.keys[k]);
-    }
-  } else {
-    for(unsigned int k = 0; k < adb->header->numFiles; k++) {
-      keys.insert((*adb->keys)[k]);
-    }
-  }
-  if(spec->refine.flags & ADB_REFINE_EXCLUDE_KEYLIST) {
-    for(unsigned int k = 0; k < spec->refine.exclude.nkeys; k++) {
-      keys.erase(spec->refine.exclude.keys[k]);
-    }
-  }
 
   if(adb->header->flags & O2_FLAG_LARGE_ADB) {
     /* FIXME: actually it would be nice to support this mode of
      * operation, but for now... */
     return 1;

   // Track loop 
   size_t data_buffer_size = 0;
   double *data_buffer = 0;
   lseek(adb->fd, adb->header->dataOffset, SEEK_SET);
 
+  std::set<std::string>::iterator keys_end = qstate->allowed_keys->end();
   for(track = 0; track < adb->header->numFiles; track++) {
     unsigned t = track;
-
-    while (keys.find((*adb->keys)[track]) == keys.end()) {
+    
+    while (qstate->allowed_keys->find((*adb->keys)[track]) == keys_end) {
       track++;
       if(track == adb->header->numFiles) {
         goto loop_finish;
       }
     }

                   r.qpos = j;
                 } else {
                   r.qpos = spec->qid.sequence_start;
                 }
                 r.ipos = k;
-                accumulator->add_point(&r);
+                qstate->accumulator->add_point(&r);
               }
             }
           }
         }
       } // Duration match