search.h

Go to the documentation of this file.

/**************************************************************
 **
 ** @file index/search.h
 **
 ** Copyright (C) 2012  Xpace, LLC.  All rights reserved
 **
 ** www.xpace.net
 **
 **************************************************************/

#ifndef XPACE_SEARCH_H
#define XPACE_SEARCH_H

#include "index/index.h"
#include "index/eval.h"
#include "index/indexlist.h"
#include "index/reflist/reflist.h"

#include "data/store/table.h"
#include "data/store/store.h"

namespace Xpace
{
  #ifdef QDOM_H
  XPACE_EXPORT void showQueryTree
    (QDomNode node,
     uint depth = 0);
  #endif

  // ================================ SEARCH TABLE ============
  
  /// Search an Index, get results from a Table to a Table
  /// @param index the Index
  /// @param table the Table from which to get results
  /// @param query the query 
  /// @return the table containing results
  XPACE_EXPORT Table searchTable
    (const Index& index,
     const Table& table,
     const String& query);

  /// Search an IndexList, get results from an Table to a Table
  /// @param indexList the IndexList
  /// @param table the Table from which to get results
  /// @param query the query 
  /// @return the table containing results
  XPACE_EXPORT Table searchTable
    (const IndexList& indexList,
     const Table& table,
     const String& query);
  
  /// Search an Index, get results from a Table to a Sink
  /// @param index the Index
  /// @param table the Table from which to get results
  /// @param query the query 
  /// @param sink call for each row and element
  /// @param sinkCount when/if to call sink->getCount()
  /// @param columns if not empty, return these columns in this order
  /// @param sort the context with which to sort (if any)
  /// @return true iff the Sink always returned true
  XPACE_EXPORT bool searchTable
    (const Index& index,
     const Table& table,
     const String& query,
     Table::Sink* sink,
     SinkNotifyCount sinkCount = SNC_After,
     const std::vector<uint>& columns = std::vector<uint>(),
     const std::vector<SortContext>& sort = std::vector<SortContext>());

  /// Search an Indexlist, get results from a Table to a Sink
  /// @param indexList the IndexList
  /// @param table the Table from which to get results
  /// @param query the query 
  /// @param sink call for each row and element
  /// @param sinkCount when to call sink->getCount()
  /// @param sort the context with which to sort (if any)
  /// @param columns if not empty, return these columns in this order
  /// @param sort the context with which to sort (if any)
  /// @return true iff the Sink always returned true
  XPACE_EXPORT bool searchTable
    (const IndexList& indexList,
     const Table& table,
     const String& query,
     Table::Sink* sink,
     SinkNotifyCount sinkCount = SNC_After,
     const std::vector<uint>& columns = std::vector<uint>(),
     const std::vector<SortContext>& sort = std::vector<SortContext>());

  /// Search IndexLists, get results from a Table to a Sink
  ///  NB Indexes, Table, and sort are fully specified in query, and must be open
  /// @param sink called for each node
  /// @return true iff the Sink always returned true
  XPACE_EXPORT bool searchTable
    (const String& query,
     Table::Sink* sink);

  // ================================ SEARCH STORE ============

  /// Search an Index, get results from a Store to a Store
  /// @param index the Index
  /// @param store the Store from which to get results
  /// @param query the query 
  /// @return the store containing results
  XPACE_EXPORT Store searchStore
    (const Index& index,
     const Store& store,
     const String& query);

  /// Search an IndexList, get results from an Store to a Store
  /// @param indexList the IndexList
  /// @param table the Store from which to get results
  /// @param query the query 
  /// @return the store containing results
  XPACE_EXPORT Store searchStore
    (const IndexList& indexList,
     const Store& table,
     const String& query);
  
  /// Search an Index, get results from a Store to a Sink
  /// @param index the Index
  /// @param store the Store from which to get results
  /// @param query the query 
  /// @param sink called for each node
  /// @param sinkCount when to call sink->getCount()
  /// @param sort the context with which to sort (if any)
  /// @param addressBy use this set of callbacks to Sink
  /// @param nodes if not empty, return these nodes in store order
  /// @return true iff the Sink always returned true
  XPACE_EXPORT bool searchStore
    (const Index& index,
     const Store& store,
     const String& query,
     Store::Sink* sink,
     SinkNotifyCount sinkCount = SNC_After,
     const std::vector<SortContext>& sort = std::vector<SortContext>(),
     Store::AddressBy addressBy = Store::AB_location,   
     const std::vector<Store::Location>& nodes = std::vector<Store::Location>());

  /// Search an Indexlist, get results from a Store to a Sink
  /// @param indexList the IndexList
  /// @param store the Store from which to get results
  /// @param query the query 
  /// @paran sink called for each node
  /// @param sinkCount when to call sink->setCount()
  /// @param sort the context with which to sort (if any)
  /// @param nodes if not empty, return these nodes in store order
  /// @param addressBy use this set of callbacks to Sink
  /// @return true iff the Sink always returned true
  XPACE_EXPORT bool searchStore
    (const IndexList& indexList,
     const Store& store,
     const String& query,
     Store::Sink* sink,
     SinkNotifyCount sinkCount = SNC_After,
     const std::vector<SortContext>& sort = std::vector<SortContext>(),
     Store::AddressBy addressBy = Store::AB_location,   
     const std::vector<Store::Location>& nodes = std::vector<Store::Location>());

  /// Search IndexLists, get results from a Store to a Sink
  ///  NB Indexes, Store, and sort are fully specified in query, and must be open
  /// @param sink called for each node
  /// @return true iff the Sink always returned true
  XPACE_EXPORT bool searchStore
    (const String& query,
     Store::Sink* sink);

  /// Thrown when a query contains an unknown or out-of-place operator
  class XPACE_EXPORT evalBadOperator : public Exception
  {
  public:
    evalBadOperator
      (String op);
  };

  /// Thrown when a query on an IndexList contains no Index identifier
  class XPACE_EXPORT evalNoIndex : public Exception
  {
  public:
    evalNoIndex
      (String query = String());
  };

}

#endif