dunedaq::oks::OksQuery Class Reference

OKS query class. More...

#include <query.hpp>

Collaboration diagram for dunedaq::oks::OksQuery:

Public Types
enum	QueryType {   unknown_type , comparator_type , relationship_type , not_type ,   and_type , or_type }
typedef bool(*)	Comparator(const OksData *, const OksData *)

Public Member Functions
	OksQuery (bool b, OksQueryExpression *q=0)
	OksQuery (const OksClass *, const std::string &)
virtual	~OksQuery ()
bool	search_in_subclasses () const
void	search_in_subclasses (bool b)
OksQueryExpression *	get () const
void	set (OksQueryExpression *q)
bool	good () const

Static Public Member Functions
static bool	equal_cmp (const OksData *, const OksData *)
static bool	not_equal_cmp (const OksData *, const OksData *)
static bool	less_or_equal_cmp (const OksData *, const OksData *)
static bool	greater_or_equal_cmp (const OksData *, const OksData *)
static bool	less_cmp (const OksData *, const OksData *)
static bool	greater_cmp (const OksData *, const OksData *)
static bool	reg_exp_cmp (const OksData *, const OksData *regexp)

Static Public Attributes
static const char *	OR = "or"
static const char *	AND = "and"
static const char *	NOT = "not"
static const char *	SOME = "some"
static const char *	THIS_CLASS = "this"
static const char *	ALL_SUBCLASSES = "all"
static const char *	OID = "object-id"
static const char *	EQ = "="
static const char *	NE = "!="
static const char *	RE = "~="
static const char *	LE = "<="
static const char *	GE = ">="
static const char *	LS = "<"
static const char *	GT = ">"
static const char *	PATH_TO = "path-to"
static const char *	DIRECT = "direct"
static const char *	NESTED = "nested"

Static Private Member Functions
static OksQueryExpression *	create_expression (const OksClass *, const std::string &)

Private Attributes
bool	p_sub_classes
OksQueryExpression *	p_expression
int	p_status

Friends
std::ostream &	operator<< (std::ostream &s, const OksQuery &gqe)

Detailed Description

OKS query class.

The class implements OKS query.
A query can be executed over some class (and optionally subclasses)

with given query expression. A query expression can be constructed dynamically for given query expression or can be read from string.

Definition at line 39 of file query.hpp.

Member Typedef Documentation

Comparator

typedef bool(*) dunedaq::oks::OksQuery::Comparator(const OksData *, const OksData *)

Definition at line 95 of file query.hpp.

Member Enumeration Documentation

QueryType

enum dunedaq::oks::OksQuery::QueryType

Enumerator
unknown_type
comparator_type
relationship_type
not_type
and_type
or_type

Definition at line 59 of file query.hpp.

  {
    unknown_type,
    comparator_type,
    relationship_type,
    not_type,
    and_type,
    or_type
  };

Constructor & Destructor Documentation

OksQuery() [1/2]

dunedaq::oks::OksQuery::OksQuery ( bool b, OksQueryExpression * q = 0 )

inline

Definition at line 42 of file query.hpp.

    : p_sub_classes(b)
    , p_expression(q)
    , p_status(0) {};

OksQuery() [2/2]

dunedaq::oks::OksQuery::OksQuery	(	const OksClass *	c,
		const std::string &	str )

Definition at line 116 of file query.cpp.

  : p_expression(0)
  , p_status(1)
{
  OSK_PROFILING(OksProfiler::fStringToQuery, c->get_kernel())
 
  const char* fname = "OksQuery::OksQuery(OksClass *, const char *)";
  const char* error_str = "Can't create query ";
 
  char delimiter = '\0';
 
  if (!c) {
    Oks::error_msg(fname) << error_str << "without specified class\n";
    return;
  }
 
  if (str.empty()) {
    Oks::error_msg(fname) << error_str << "from empty string\n";
    return;
  }
 
  std::string s(str);
 
  erase_empty_chars(s);
 
  if (s.empty()) {
    Oks::error_msg(fname) << error_str << "from string which consists of space symbols\n";
    return;
  }
 
  if (s[0] == '(') {
    s.erase(0, 1);
    delimiter = ')';
  }
 
  std::string::size_type p = s.find(' ');
 
  if (p == std::string::npos) {
    Oks::error_msg(fname) << "Can't parse query expression \"" << str
                          << "\"\n"
                             "it must consists of as minimum two tokens separated by space\n";
    return;
  }
 
  if (s.substr(0, p) == OksQuery::ALL_SUBCLASSES)
    p_sub_classes = true;
  else if (s.substr(0, p) == OksQuery::THIS_CLASS)
    p_sub_classes = false;
  else {
    Oks::error_msg(fname) << "Can't parse query expression \"" << str
                          << "\"\n"
                             "the first token must be \'"
                          << OksQuery::ALL_SUBCLASSES << "\' or \'" << OksQuery::THIS_CLASS << "\'\n";
    return;
  }
 
  s.erase(0, p + 1);
 
  if (delimiter == ')') {
    p = s.rfind(delimiter);
    if (p == std::string::npos) {
      Oks::error_msg(fname) << "Can't parse query expression \"" << str
                            << "\"\n"
                               "it must contain closing bracket \')\' if it has opening bracket \'(\'\n";
      return;
    }
 
    s.erase(p);
  }
 
  erase_empty_chars(s);
 
  if (s[0] == '(') {
    p = s.rfind(')');
 
    if (p == std::string::npos) {
      Oks::error_msg(fname) << "Can't parse query expression \"" << s
                            << "\"\n"
                               "it must contain closing bracket \')\' if it has opening bracket \'(\'\n";
      return;
    }
 
    s.erase(p);
    s.erase(0, 1);
 
    p_expression = create_expression(c, s);
 
    if (p_expression)
      p_status = 0;
  } else
    Oks::error_msg(fname) << "Can't parse subquery expression \"" << s
                          << "\"\n"
                             "it must be enclosed by brackets\n";
}

~OksQuery()

dunedaq::oks::OksQuery::~OksQuery ( )

inlinevirtual

Definition at line 293 of file query.hpp.

{
  delete p_expression;
}

Member Function Documentation

create_expression()

OksQueryExpression * dunedaq::oks::OksQuery::create_expression ( const OksClass * c, const std::string & str )

staticprivate

Definition at line 212 of file query.cpp.

{
  const char* fname = "OksQuery::create_expression()";
 
  OSK_PROFILING(OksProfiler::fStringToQueryExpression, c->get_kernel())
 
  OksQueryExpression* qe = 0;
 
  if (!c) {
    Oks::error_msg(fname) << "Can't create query without specified class\n";
    return qe;
  }
 
  if (str.empty()) {
    Oks::error_msg(fname) << "Can't create query from empty string\n";
    return qe;
  }
 
  std::string s(str);
 
  std::list<std::string> slist;
 
  while (s.length()) {
    erase_empty_chars(s);
 
    if (!s.length())
      break;
 
    if (s[0] == '\"' || s[0] == '\'' || s[0] == '`') {
      char delimiter = s[0];
      s.erase(0, 1);
 
      std::string::size_type p = s.find(delimiter);
 
      if (p == std::string::npos) {
        Oks::error_msg(fname) << "Can't parse query expression \"" << str
                              << "\"\n"
                                 "the delimiter is \' "
                              << delimiter
                              << " \'\n"
                                 "the rest of the expression is \""
                              << s << "\"\n";
        return qe;
      }
 
      s.erase(p, 1);
      slist.push_back(std::string(s, 0, p));
 
      s.erase(0, p + 1);
    } else if (s[0] == '(') {
      std::string::size_type p = 1;
      size_t strLength = s.length();
      size_t r = 1;
 
      while (p < strLength) {
        if (s[p] == '(')
          r++;
        if (s[p] == ')') {
          r--;
          if (!r)
            break;
        }
        p++;
      }
 
      if (r) {
        Oks::error_msg(fname) << "Can't parse query expression \"" << str << "\"\n"
                              << "There is no closing \')\' for " << '\"' << s << "\"\n";
        return qe;
      }
 
      s.erase(p, 1);
      s.erase(0, 1);
 
      slist.push_back(std::string(s, 0, p - 1));
 
      s.erase(0, p - 1);
    } else {
      std::string::size_type p = 0;
      size_t strLength = s.length();
 
      while (p < strLength && s[p] != ' ')
        p++;
 
      slist.push_back(std::string(s, 0, p));
 
      s.erase(0, p);
    }
  }
 
  if (slist.empty()) {
    Oks::error_msg(fname) << "Can't create query from empty string \"" << str << "\"\n";
    return qe;
  }
 
  const std::string first = slist.front();
  slist.pop_front();
 
  if (first == OksQuery::AND || first == OksQuery::OR) {
    if (slist.size() < 2) {
      Oks::error_msg(fname) << "\'" << first << "\' must have two or more arguments: (" << str << ")'\n";
      return qe;
    }
 
    qe = ((first == OksQuery::AND) ? (OksQueryExpression*)new OksAndExpression()
                                   : (OksQueryExpression*)new OksOrExpression());
 
    while (!slist.empty()) {
      const std::string item2 = slist.front();
      slist.pop_front();
 
      OksQueryExpression* qe2 = create_expression(c, item2);
 
      if (qe2) {
        if (first == OksQuery::AND)
          ((OksAndExpression*)qe)->add(qe2);
        else
          ((OksOrExpression*)qe)->add(qe2);
      }
    }
 
    return qe; /* SUCCESS */
  } else if (first == OksQuery::NOT) {
    if (slist.size() != 1) {
      Oks::error_msg(fname) << "\'" << first << "\' must have exactly one argument: (" << str << ")\n";
      return qe;
    }
 
    qe = (OksQueryExpression*)new OksNotExpression();
 
    const std::string item2 = slist.front();
    slist.pop_front();
 
    OksQueryExpression* qe2 = create_expression(c, item2);
 
    if (qe2)
      ((OksNotExpression*)qe)->set(qe2);
 
    return qe; /* SUCCESS */
  } else if (slist.size() != 2) {
    Oks::error_msg(fname) << "Can't parse query expression \"" << str << "\"\n";
    return qe;
  } else {
    const std::string second = slist.front();
    slist.pop_front();
 
    const std::string third = slist.front();
    slist.pop_front();
 
    if (second == OksQuery::SOME || second == OksQuery::ALL_SUBCLASSES) {
      OksRelationship* r = c->find_relationship(first);
 
      if (!r) {
        Oks::error_msg(fname) << "For expression \"" << str
                              << "\"\n"
                                 "can't find relationship \""
                              << first << "\" in class \"" << c->get_name() << "\"\n";
 
        return qe;
      }
 
      bool b;
 
      if (second == OksQuery::SOME)
        b = false;
      else if (second == OksQuery::ALL_SUBCLASSES)
        b = true;
      else {
        Oks::error_msg(fname) << "For relationship expression \"" << str
                              << "\"\n"
                                 "second parameter \'"
                              << second << "\' must be \'" << *OksQuery::SOME << "\' or \'" << *OksQuery::ALL_SUBCLASSES
                              << "\'\n";
        return qe;
      }
 
      OksClass* relc = c->get_kernel()->find_class(r->get_type());
 
      if (!relc) {
        Oks::error_msg(fname) << "For expression \"" << str << "\"\n"
                              << "can't find class \"" << r->get_type() << "\"\n";
        return qe;
      }
 
      OksQueryExpression* qe2 = create_expression(relc, third);
 
      if (qe2)
        qe = (OksQueryExpression*)new OksRelationshipExpression(r, qe2, b);
 
      return qe; /* SUCCESS */
    } else {
      OksAttribute* a = ((first != OksQuery::OID) ? c->find_attribute(first) : 0);
 
      if (first != OksQuery::OID && !a) {
        Oks::error_msg(fname) << "For expression \"" << str << "\"\n"
                              << "can't find attribute \"" << first << "\" in class \"" << c->get_name() << "\"\n";
        return qe;
      }
 
      OksData* d = new OksData();
 
      OksQuery::Comparator f = ((third == OksQuery::EQ)   ? OksQuery::equal_cmp
                                : (third == OksQuery::NE) ? OksQuery::not_equal_cmp
                                : (third == OksQuery::RE) ? OksQuery::reg_exp_cmp
                                : (third == OksQuery::LE) ? OksQuery::less_or_equal_cmp
                                : (third == OksQuery::GE) ? OksQuery::greater_or_equal_cmp
                                : (third == OksQuery::LS) ? OksQuery::less_cmp
                                : (third == OksQuery::GT) ? OksQuery::greater_cmp
                                                          : 0);
 
      if (a) {
        if (f == OksQuery::reg_exp_cmp) {
          d->type = OksData::string_type;
          d->data.STRING = new OksString(second);
        } else {
          d->type = OksData::unknown_type;
          d->SetValues(second.c_str(), a);
        }
      } else {
        d->Set(second);
      }
 
      if (!f)
        Oks::error_msg(fname) << "For expression \"" << str << "\"\n"
                              << "can't find comparator function \"" << third << "\"\n";
      else
        qe = (OksQueryExpression*)new OksComparator(a, d, f);
 
      return qe; /* (UN)SUCCESS */
    }
  }
}

equal_cmp()

bool dunedaq::oks::OksQuery::equal_cmp ( const OksData * d1, const OksData * d2 )

static

Definition at line 56 of file query.cpp.

{
  return (*d1 == *d2);
}

get()

OksQueryExpression * dunedaq::oks::OksQuery::get ( ) const

inline

Definition at line 54 of file query.hpp.

{ return p_expression; }

good()

bool dunedaq::oks::OksQuery::good ( ) const

inline

Definition at line 57 of file query.hpp.

{ return (p_status == 0); }

greater_cmp()

bool dunedaq::oks::OksQuery::greater_cmp ( const OksData * d1, const OksData * d2 )

static

Definition at line 81 of file query.cpp.

{
  return (*d1 > *d2);
}

greater_or_equal_cmp()

bool dunedaq::oks::OksQuery::greater_or_equal_cmp ( const OksData * d1, const OksData * d2 )

static

Definition at line 71 of file query.cpp.

{
  return (*d1 >= *d2);
}

less_cmp()

bool dunedaq::oks::OksQuery::less_cmp ( const OksData * d1, const OksData * d2 )

static

Definition at line 76 of file query.cpp.

{
  return (*d1 < *d2);
}

less_or_equal_cmp()

bool dunedaq::oks::OksQuery::less_or_equal_cmp ( const OksData * d1, const OksData * d2 )

static

Definition at line 66 of file query.cpp.

{
  return (*d1 <= *d2);
}

not_equal_cmp()

bool dunedaq::oks::OksQuery::not_equal_cmp ( const OksData * d1, const OksData * d2 )

static

Definition at line 61 of file query.cpp.

{
  return (*d1 != *d2);
}

reg_exp_cmp()

bool dunedaq::oks::OksQuery::reg_exp_cmp ( const OksData * d, const OksData * regexp )

static

Definition at line 86 of file query.cpp.

{
  return boost::regex_match(d->str(), *reinterpret_cast<const boost::regex*>(re));
}

search_in_subclasses() [1/2]

bool dunedaq::oks::OksQuery::search_in_subclasses ( ) const

inline

Definition at line 51 of file query.hpp.

{ return p_sub_classes; }

search_in_subclasses() [2/2]

void dunedaq::oks::OksQuery::search_in_subclasses ( bool b )

inline

Definition at line 52 of file query.hpp.

{ p_sub_classes = b; }

set()

void dunedaq::oks::OksQuery::set ( OksQueryExpression * q )

inline

Definition at line 55 of file query.hpp.

{ p_expression = q; }

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & s, const OksQuery & gqe )

friend

Definition at line 881 of file query.cpp.

{
  s << '(' << (gqe.p_sub_classes ? OksQuery::ALL_SUBCLASSES : OksQuery::THIS_CLASS) << ' ';
 
  if (gqe.p_expression)
    s << *gqe.p_expression;
  else
    s << "(null)";
 
  s << ')';
 
  return s;
}

Member Data Documentation

ALL_SUBCLASSES

const char * dunedaq::oks::OksQuery::ALL_SUBCLASSES = "all"

static

Definition at line 74 of file query.hpp.

AND

const char * dunedaq::oks::OksQuery::AND = "and"

static

Definition at line 70 of file query.hpp.

DIRECT

const char * dunedaq::oks::OksQuery::DIRECT = "direct"

static

Definition at line 84 of file query.hpp.

EQ

const char * dunedaq::oks::OksQuery::EQ = "="

static

Definition at line 76 of file query.hpp.

GE

const char * dunedaq::oks::OksQuery::GE = ">="

static

Definition at line 80 of file query.hpp.

GT

const char * dunedaq::oks::OksQuery::GT = ">"

static

Definition at line 82 of file query.hpp.

LE

const char * dunedaq::oks::OksQuery::LE = "<="

static

Definition at line 79 of file query.hpp.

LS

const char * dunedaq::oks::OksQuery::LS = "<"

static

Definition at line 81 of file query.hpp.

NE

const char * dunedaq::oks::OksQuery::NE = "!="

static

Definition at line 77 of file query.hpp.

NESTED

const char * dunedaq::oks::OksQuery::NESTED = "nested"

static

Definition at line 85 of file query.hpp.

NOT

const char * dunedaq::oks::OksQuery::NOT = "not"

static

Definition at line 71 of file query.hpp.

OID

const char * dunedaq::oks::OksQuery::OID = "object-id"

static

Definition at line 75 of file query.hpp.

OR

const char * dunedaq::oks::OksQuery::OR = "or"

static

Definition at line 69 of file query.hpp.

p_expression

OksQueryExpression* dunedaq::oks::OksQuery::p_expression

private

Definition at line 99 of file query.hpp.

p_status

int dunedaq::oks::OksQuery::p_status

private

Definition at line 100 of file query.hpp.

p_sub_classes

bool dunedaq::oks::OksQuery::p_sub_classes

private

Definition at line 98 of file query.hpp.

PATH_TO

const char * dunedaq::oks::OksQuery::PATH_TO = "path-to"

static

Definition at line 83 of file query.hpp.

RE

const char * dunedaq::oks::OksQuery::RE = "~="

static

Definition at line 78 of file query.hpp.

SOME

const char * dunedaq::oks::OksQuery::SOME = "some"

static

Definition at line 72 of file query.hpp.

THIS_CLASS

const char * dunedaq::oks::OksQuery::THIS_CLASS = "this"

static

Definition at line 73 of file query.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/oks/include/oks/query.hpp
• /github/workspace/dunedaq/sourcecode/oks/src/query.cpp