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 35 of file query.hpp.

Member Typedef Documentation

Comparator

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

Definition at line 88 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 53 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 39 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 85 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 303 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 182 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 51 of file query.cpp.

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

get()

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

inline

Definition at line 48 of file query.hpp.

{return p_expression;}

good()

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

inline

Definition at line 51 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 56 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 54 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 55 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 53 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 52 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 57 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 45 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 46 of file query.hpp.

{p_sub_classes = b;}

set()

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

inline

Definition at line 49 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 891 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 67 of file query.hpp.

AND

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

static

Definition at line 63 of file query.hpp.

DIRECT

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

static

Definition at line 77 of file query.hpp.

EQ

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

static

Definition at line 69 of file query.hpp.

GE

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

static

Definition at line 73 of file query.hpp.

GT

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

static

Definition at line 75 of file query.hpp.

LE

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

static

Definition at line 72 of file query.hpp.

LS

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

static

Definition at line 74 of file query.hpp.

NE

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

static

Definition at line 70 of file query.hpp.

NESTED

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

static

Definition at line 78 of file query.hpp.

NOT

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

static

Definition at line 64 of file query.hpp.

OID

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

static

Definition at line 68 of file query.hpp.

OR

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

static

Definition at line 62 of file query.hpp.

p_expression

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

private

Definition at line 94 of file query.hpp.

p_status

int dunedaq::oks::OksQuery::p_status

private

Definition at line 95 of file query.hpp.

p_sub_classes

bool dunedaq::oks::OksQuery::p_sub_classes

private

Definition at line 93 of file query.hpp.

PATH_TO

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

static

Definition at line 76 of file query.hpp.

RE

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

static

Definition at line 71 of file query.hpp.

SOME

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

static

Definition at line 65 of file query.hpp.

THIS_CLASS

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

static

Definition at line 66 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