QueryEnvironment.hpp

Go to the documentation of this file.

/*==========================================================================
 * Copyright (c) 2004 University of Massachusetts.  All Rights Reserved.
 *
 * Use of the Lemur Toolkit for Language Modeling and Information Retrieval
 * is subject to the terms of the software license set forth in the LICENSE
 * file included with this software, and also available at
 * http://www.lemurproject.org/license.html
 *
 *==========================================================================
 */


//
// QueryEnvironment
//
// 9 March 2004 -- tds
//

#ifndef INDRI_QUERYENVIRONMENT_HPP
#define INDRI_QUERYENVIRONMENT_HPP

#include <map>
#include "indri/ScoredExtentResult.hpp"
#include "indri/QueryServer.hpp"
#include "indri/NetworkStream.hpp"
#include "indri/NetworkMessageStream.hpp"
#include "indri/Parameters.hpp"
#include "indri/ParsedDocument.hpp"
#include "indri/Repository.hpp"
#include "indri/QueryAnnotation.hpp"
#include "IndexTypes.hpp"

namespace indri 
{
  namespace api 
  {
    typedef struct QueryRequest 
    {
      enum Options {
        HTMLSnippet = 1,
        TextSnippet = 2
      };
      std::string query;
      std::vector<std::string> formulators;
      std::vector<std::string>  metadata;
      std::vector<lemur::api::DOCID_T>  docSet;
      int resultsRequested;
      int startNum;
      enum Options options;
    } QueryRequest;

    typedef struct MetadataPair 
    {
      std::string key;
      std::string value;
    } MetadataPair;
    
    typedef struct QueryResult
    {
      std::string snippet;
      std::string documentName;
      lemur::api::DOCID_T docid;
      double score;
      int begin;
      int end;
      std::vector<indri::api::MetadataPair> metadata;
    } QueryResult;

    typedef struct QueryResults 
    {
      float parseTime;
      float executeTime;
      float documentsTime;
      int estimatedMatches;
      std::vector<QueryResult> results;
    } QueryResults;
    
    class QueryEnvironment {
    private:
      // first is entry in _servers, second is entry _streams
      // derive idx to erase from those.
      std::map<std::string, std::pair<indri::server::QueryServer *, indri::net::NetworkStream *> > _serverNameMap;
      std::vector<indri::server::QueryServer*> _servers;
      // first is entry _servers, second is entry in _repositories.
      // derive idx to erase from those.
      std::map<std::string, std::pair<indri::server::QueryServer *, indri::collection::Repository *> > _repositoryNameMap;
      std::vector<indri::collection::Repository*> _repositories;
      std::vector<indri::net::NetworkStream*> _streams;
      std::vector<indri::net::NetworkMessageStream*> _messageStreams;

      Parameters _parameters;
      bool _baseline;
      
      void _mergeQueryResults( indri::infnet::InferenceNetwork::MAllResults& results, std::vector<indri::server::QueryServerResponse*>& responses );
      void _copyStatistics( std::vector<indri::lang::RawScorerNode*>& scorerNodes, indri::infnet::InferenceNetwork::MAllResults& statisticsResults );

      std::vector<indri::server::QueryServerResponse*> _runServerQuery( std::vector<indri::lang::Node*>& roots, int resultsRequested );
      void _sumServerQuery( indri::infnet::InferenceNetwork::MAllResults& results, std::vector<indri::lang::Node*>& roots, int resultsRequested );
      void _mergeServerQuery( indri::infnet::InferenceNetwork::MAllResults& results, std::vector<indri::lang::Node*>& roots, int resultsRequested );
      void _annotateQuery( indri::infnet::InferenceNetwork::MAllResults& results, const std::vector<lemur::api::DOCID_T>& documentIDs, std::string& annotatorName, indri::lang::Node* queryRoot );

      std::vector<indri::api::ScoredExtentResult> _runQuery( indri::infnet::InferenceNetwork::MAllResults& results,
                                                             const std::string& q,
                                                             int resultsRequested,
                                                             const std::vector<lemur::api::DOCID_T>* documentIDs,
                                                             QueryAnnotation** annotation,
                                                             const std::string &queryType = "indri" );
      void _scoredQuery( indri::infnet::InferenceNetwork::MAllResults& results, indri::lang::Node* queryRoot, std::string& accumulatorName, int resultsRequested, const std::vector<lemur::api::DOCID_T>* documentSet );

      QueryEnvironment( QueryEnvironment& other ) {}

    public:
      QueryEnvironment();
      ~QueryEnvironment();
      void setMemory( UINT64 memory );
      void setBaseline(const std::string &baseline);
      void setSingleBackgroundModel( bool background );
      void setScoringRules( const std::vector<std::string>& rules );
      void setStopwords( const std::vector<std::string>& stopwords );
      void addServer( const std::string& hostname );
      void addIndex( const std::string& pathname );
      void addIndex( class IndexEnvironment& environment );
      void close();
      void removeServer( const std::string& hostname );
      void removeIndex( const std::string& pathname );

      QueryResults runQuery(QueryRequest &request);

      std::vector<indri::api::ScoredExtentResult> runQuery( const std::string& query, int resultsRequested, const std::string &queryType = "indri" );

      std::vector<indri::api::ScoredExtentResult> runQuery( const std::string& query, const std::vector<lemur::api::DOCID_T>& documentSet, int resultsRequested, const std::string &queryType = "indri" );

      QueryAnnotation* runAnnotatedQuery( const std::string& query, int resultsRequested, const std::string &queryType = "indri" );  

      QueryAnnotation* runAnnotatedQuery( const std::string& query, const std::vector<lemur::api::DOCID_T>& documentSet, int resultsRequested, const std::string &queryType = "indri" );


      std::vector<indri::api::ParsedDocument*> documents( const std::vector<lemur::api::DOCID_T>& documentIDs );
      std::vector<indri::api::ParsedDocument*> documents( const std::vector<indri::api::ScoredExtentResult>& results );
      std::vector<std::string> documentMetadata( const std::vector<lemur::api::DOCID_T>& documentIDs, const std::string& attributeName );
      std::vector<std::string> documentMetadata( const std::vector<indri::api::ScoredExtentResult>& documentIDs, const std::string& attributeName );

      std::vector<std::string> pathNames( const std::vector<indri::api::ScoredExtentResult>& results );


      std::vector<indri::api::ParsedDocument*> documentsFromMetadata( const std::string& attributeName, const std::vector<std::string>& attributeValues );

      std::vector<lemur::api::DOCID_T> documentIDsFromMetadata( const std::string& attributeName, const std::vector<std::string>& attributeValue );

      INT64 termCount();
      INT64 termCount( const std::string& term );
      INT64 stemCount( const std::string& term );
      INT64 termFieldCount( const std::string& term, const std::string& field );
      INT64 stemFieldCount( const std::string& term, const std::string& field );
      double expressionCount( const std::string& expression,
                              const std::string &queryType = "indri" );
      std::vector<ScoredExtentResult> expressionList( const std::string& expression, 
                                                      const std::string& queryType = "indri" );
      std::vector<std::string> fieldList();
      INT64 documentCount();
      INT64 documentCount( const std::string& term );

      INT64 documentStemCount( const std::string& stem );

      int documentLength(lemur::api::DOCID_T documentID);
      
      std::vector<DocumentVector*> documentVectors( const std::vector<lemur::api::DOCID_T>& documentIDs );

      void setMaxWildcardTerms(int maxTerms);
      const std::vector<indri::server::QueryServer*>& getServers() const { return _servers;
      }
      
    };
  }
}

#endif // INDRI_QUERYENVIRONMENT_HPP

---