eval.h

Go to the documentation of this file.

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

#ifndef XPACE_EVAL_H
#define XPACE_EVAL_H

#include <functional>

#include <QtCore/qregexp.h>

#include "base/types.h"
#include "base/exception.h"
#include "index/searchnames.h"

namespace Xpace
{
  // thrown when an index can't be opened
  class XPACE_EXPORT evalCantOpenIndex : public Exception
  {
  public:
    evalCantOpenIndex
      (String indexName);
  };

  // thrown when a regex search is requested of an index that does not support them
  class XPACE_EXPORT evalCantRegex : public Exception
  {
  public:
    evalCantRegex
      (String indexName);
  };

  // thrown when an invalid regex is passed
  class XPACE_EXPORT evalInvalidRegex : public Exception
  {
  public:
    evalInvalidRegex
      (String regex);
  };

  // ================================ FIND ====================

  #ifdef QDOM_H
  template <typename INDEX>
  typename INDEX::Iter find_term
    (const INDEX& index,
     QDomNode termNode,
     bool* found = 0)
  {  
    QDomNode tn(termNode.hasChildNodes() ? termNode.firstChild() : termNode);
    String val(tn.nodeValue());

    return index.begin(val, found);
  }
  #endif

  template <typename INDEX, typename STR>
  typename INDEX::Iter find_term
    (const INDEX& index,
     const STR& val,
     bool* found = 0)
  {  
    return index.begin(val, found);
  }

  // ================================ RANGE ===================

  template <typename REFLISTCURSOR, typename INDEX_ITER>
  REFLISTCURSOR eval_range
    (const INDEX_ITER& begin,
     const INDEX_ITER& end)
  {
    return begin.getRefList(end);
  }

  #ifdef QDOM_H
  // ================================ REGEX ===================

  template <typename REFLISTCURSOR, typename INDEX>
  REFLISTCURSOR eval_regex(const INDEX& index, QDomNode node)
  {
    QDomNode tn(node.hasChildNodes() ? node.firstChild() : node);
    QString val(tn.nodeValue());

    static QString regex_chars("*?+(){}|.^$\\{}");

    uint literal_chars(0);
    bool use_regex(false);

    auto ch(val.begin()); 
    if (ch == val.end())
      return REFLISTCURSOR();
    
    if (*ch == '^')
      ++ch;

    for ( ; ch < val.end(); ++ch)
    {
      int i(regex_chars.indexOf(*ch));
      if (i == -1)
        ++literal_chars;
      else
      {
        use_regex = true;
        break;
      }
    }

    typename INDEX::Iter it, end;
    if (use_regex)
    {
      it = index.begin();
      end = index.end();

      QRegExp regex(val);
      if (!regex.isValid())
        throw evalInvalidRegex(val);

      REFLISTCURSOR result;
      for ( ; it.diff(end); it.move(1))
        if (regex.exactMatch(it.getTerm()))
        {
          REFLISTCURSOR refs(it.getRefList());
          result.opOr(&refs);
        }
      return result;
    }

    // no regex - just a truncation
    QString start_term(val);
    start_term.truncate(literal_chars);
    REVEAL_STRING(sstr, start_term);
    it = index.begin(start_term);
    QString end_term(index.next(start_term));
    REVEAL_STRING(estr, end_term);
    end = index.begin(end_term);
    
    return it.getRefList(end);
  }

  // ================================ EVAL ====================

  QDomNode parseQuery
    (String query);

  template <typename REFLISTCURSOR, typename INDEXLIST, typename INDEX>
  REFLISTCURSOR eval
    (const INDEXLIST& indexList,
     QDomNode node,
     uint64 recCount,
     uint depth,
     std::function<const INDEX(const INDEXLIST& indexList, 
                               const QDomNode& node,
                               String* indexName)> getIndex,
     bool isAnd = false)
  {
    if (node.isNull())
      return REFLISTCURSOR();

    QString name(node.nodeName());
    REVEAL_STRING(n, name);

    if ((name == SearchNames::DOCUMENT_TAG) || 
        (name == SearchNames::QUERY_TAG)    || 
        (name == SearchNames::SEARCH_TAG)   ||
        (name == SearchNames::PARSE_TREE_TAG))
      return eval<REFLISTCURSOR, INDEXLIST, INDEX>(indexList, node.firstChild(), recCount, depth + 1, getIndex);

    std::vector<REFLISTCURSOR> to_and;

    do  // for each sibling
    {
      REFLISTCURSOR result; // this will be the result for this sibling
      bool skip = false;

      if (name == SearchNames::OP_NOT)
      {
        result = eval<REFLISTCURSOR, INDEXLIST, INDEX>(indexList, node.firstChild(), recCount, depth + 1, getIndex);
        result.opNot(recCount);
      } // not

      else if (name == SearchNames::OP_OR)
      {
        QDomNode child(node.firstChild());
        result = eval<REFLISTCURSOR, INDEXLIST, INDEX>(indexList, child, recCount, depth + 1, getIndex);
        while (!(child = child.nextSibling()).isNull())
        {
          REFLISTCURSOR sibling(eval<REFLISTCURSOR, INDEXLIST, INDEX>(indexList, child, recCount, depth + 1, getIndex));
          result.opOr(&sibling);
        }
      } // or

      else
      {
        String index_name;
        const INDEX& index(getIndex(indexList, node, &index_name));

        #ifdef QREGEXP_H
        if (name == SearchNames::OP_REGEX)
        {
          if (!index.regexOK())
            throw evalCantRegex(index_name);
          result = eval_regex<REFLISTCURSOR, INDEX>(index, node);
        } // regex
        else 
        #endif

        if ((name == SearchNames::OP_EQ)   || 
            (name == SearchNames::OP_NE)   ||
            (name == SearchNames::OP_TERM) || 
            (name == SearchNames::OP_PHRASE))
        {
          if (!index)
            throw evalCantOpenIndex(index_name);

          bool found;
          typename INDEX::Iter it(find_term(index, node, &found));
          result = (found) ? it.getRefList() : REFLISTCURSOR();

          if (name == SearchNames::OP_NE)
            result.opNot(recCount);

        } // eq, term, phrase

        else if (name == SearchNames::OP_LT)
        {
          if (!index)
            throw evalCantOpenIndex(index_name);

          bool found;
          typename INDEX::Iter end(find_term(index, node.firstChild(), &found));
          result = eval_range<REFLISTCURSOR>(index.begin(), end);
        } // lt
    
        else if (name == SearchNames::OP_GT)
        {
          if (!index)
            throw evalCantOpenIndex(index_name);

          bool found;
          typename INDEX::Iter begin(find_term(index, node.firstChild(), &found));
          if (!found || begin.move(1))
            result = eval_range<REFLISTCURSOR>(begin, index.end());
        } // gt

        else if (name == SearchNames::OP_LE)
        {
          if (!index)
            throw evalCantOpenIndex(index_name);

          bool found;
          typename INDEX::Iter end(find_term(index, node.firstChild(), &found));
          if (found)
            end.move(1);
          result = eval_range<REFLISTCURSOR>(index.begin(), end);
        } // le
    
        else if (name == SearchNames::OP_GE)
        {
          if (!index)
            throw evalCantOpenIndex(index_name);

          // see if this is really a range search (TODO move this into a general search planner
          QDomNode next(node.nextSibling());
          if (!next.isNull() && (next.nodeName() == SearchNames::OP_LE) && next.nextSibling().isNull() &&
              (node.toElement().attribute(SearchNames::INDEX_TAG) == next.toElement().attribute(SearchNames::INDEX_TAG)))
          {
            // it is a range search
            bool found;
            typename INDEX::Iter begin(find_term(index, node.firstChild(), &found));
            typename INDEX::Iter   end(find_term(index, next.firstChild(), &found));
            if (found)
              end.move(1);
            result = eval_range<REFLISTCURSOR>(begin, end);
            node = next;
          }

          else
          {
            // not a range search
            bool found;
            typename INDEX::Iter begin(find_term(index, node.firstChild(), &found));
            result = eval_range<REFLISTCURSOR>(begin, index.end());
          }
        } // ge

        else if (name == SearchNames::OP_ALL)
        {
          if (!index)
            throw evalCantOpenIndex(index_name);

          // TODO: optimize all search
          return eval_range<REFLISTCURSOR>(index.begin(), index.end());
        } // all

        else if (name == SearchNames::OP_AND)
          result = eval<REFLISTCURSOR, INDEXLIST, INDEX>(indexList, node.firstChild(), recCount, depth + 1, getIndex, true);

        else
          // skip unrecognized branch
          skip = true;
      }

      if (!skip)
      {
        if (!!result)
          to_and.push_back(result);
        else
          // and-ing with 0
          return REFLISTCURSOR();
      }
    
      if ((node = node.nextSibling()).isNull())
        break;
      name = node.nodeName();
    }
    while (isAnd);  // default search is And; if not, just return

    return REFLISTCURSOR::opAnd(&to_and);
  };
  #endif
}

#endif