Query.h

Go to the documentation of this file.

//-*- Mode: C++ -*-
//  DDC originally by Alexey Sokirko
//  Changes and modifications 2011-2020 by Bryan Jurish
//
//  This file is part of DDC.
// 
//  DDC is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
// 
//  DDC is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
// 
//  You should have received a copy of the GNU Lesser General Public License
//  along with DDC.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef DDC_QUERY_H
#define DDC_QUERY_H

#include "../ConcordLib/QueryNode.h"    //-- DDC-v1.x query API, wrapped here
#include "../ConcordLib/QueryOptions.h"

extern const BYTE DefaultMatchId;

//======================================================================
class CQuery : public ddcObject {
public:
    string m_Label;

    CQueryCompiler *m_Compiler;

    CQueryNode *m_Node;

    CQueryOptions *m_Options;

public:
    //------------------------------------------------------------

    CQuery(const string &label=string(""))
        : m_Label(label),
          m_Compiler(NULL),
          m_Node(NULL),
          m_Options(NULL)
    {};

    virtual ~CQuery(void);

public:
    //------------------------------------------------------------

    virtual bool CheckSatisfiable(CQueryCompiler *compiler);
    
    virtual bool Compile(CQueryCompiler *compiler);

    virtual bool CompileOptions(CQueryCompiler *compiler=NULL);

    virtual void Evaluate();

    virtual bool Negated() { return false; };

    virtual bool Negate();

    virtual BYTE GetMatchId() const;

    virtual BYTE SetMatchId(BYTE matchId);

    virtual bool HasMatchId() const;

    virtual bool RootOK()
    { return !this->Negated(); };

    //------------------------------------------------------------

    virtual ddcObjectList Children() const;

    virtual void DisownChildren();

    //------------------------------------------------------------

    virtual string toString() { return m_Label; };

    virtual string optionsToString();

    virtual string optionsToJson();

    virtual string toJson() { return string("{\"class\":"+jsonStr(this->jsonClass())+","+this->jsonData()+"}"); };
    virtual string jsonClass() { return "CQuery"; };
    virtual string jsonData()  { return ""; };

    //------------------------------------------------------------

    void SetCompiler(CQueryCompiler *compiler);

    virtual void ClearNode();

    virtual void ClearOptions();

    virtual void Clear(bool deep=true);

    virtual void SetOptions(CQueryOptions *opts);
};

//======================================================================
class CQNegatable : public CQuery {
public:
    bool m_Negated;

public:
    CQNegatable(const string &label=string(""), bool negated=false)
        : CQuery(label), m_Negated(negated)
    {};
    CQNegatable(bool negated)
        : m_Negated(negated)
    {};

    virtual ~CQNegatable() {};

    virtual bool Negate(void);

    virtual bool Negated() { return m_Negated; };

    virtual string NegString(const std::string &s);

    virtual bool Compile(CQueryCompiler *compiler);

    //-- ddcObject API
    virtual string jsonClass() { return "CQNegatable"; };
    virtual string jsonData()  { return string("\"Negated\":")+(m_Negated ? "1" : "0"); };
};

//======================================================================
class CQAtomic : public CQNegatable {
public:
    CQAtomic(const string &label=string(""), bool negated=false)
        : CQNegatable(label,negated)
    {};
    virtual ~CQAtomic() {};

    //-- ddcObject API
    virtual string jsonClass() { return "CQAtomic"; };
};


//======================================================================
// CQBinOp: Binary operations

//------------------------------------------------------------
class CQBinOp : public CQNegatable {
public:
    CQuery *m_dtr1;

    CQuery *m_dtr2;

    string m_OpName;

public:
    CQBinOp(CQuery *dtr1=NULL, CQuery *dtr2=NULL, const string &opName="", bool negated=false)
        : CQNegatable(opName,negated), m_dtr1(dtr1), m_dtr2(dtr2), m_OpName(opName)
    {};

    virtual ~CQBinOp();

    virtual BYTE GetMatchId() const;

    virtual BYTE SetMatchId(BYTE matchId);

    virtual void ClearNode();

    virtual void Clear(bool deep=true);

    virtual bool Compile(CQueryCompiler *compiler);

    //-- ddcObject API
    virtual ddcObjectList Children() const;
    virtual void DisownChildren();
    virtual string toString();
    virtual string jsonClass() { return "CQBinOp"; };
    virtual string jsonData();
};

//------------------------------------------------------------
class CQAnd : public CQBinOp {
public:
    CQAnd(CQuery *dtr1=NULL, CQuery *dtr2=NULL)
        : CQBinOp(dtr1,dtr2,"&&")
    {};
    virtual ~CQAnd() {};

    virtual bool RootOK() { return true; };
    virtual bool Compile(CQueryCompiler *compiler);
    virtual string jsonClass() { return "CQAnd"; };
};

//------------------------------------------------------------
class CQAndImplicit : public CQAnd {
public:
    CQAndImplicit(CQuery *dtr1=NULL, CQuery *dtr2=NULL)
        : CQAnd(dtr1,dtr2)
    {
        //m_OpName.clear();
    };

    virtual ~CQAndImplicit() {};

    virtual string jsonClass() { return "CQAndImplicit"; };
};

//------------------------------------------------------------
class CQOr : public CQBinOp {
public:
    CQOr(CQuery *dtr1=NULL, CQuery *dtr2=NULL)
        : CQBinOp(dtr1,dtr2,"||")
    {};
    virtual ~CQOr() {};

    virtual bool RootOK() { return true; };
    virtual bool Compile(CQueryCompiler *compiler);
    virtual string jsonClass() { return "CQOr"; };
};

//------------------------------------------------------------
class CQWith : public CQBinOp {
public:
    BYTE m_MatchId;

public:
    CQWith(CQuery *dtr1=NULL, CQuery *dtr2=NULL, BYTE matchId=0)
        : CQBinOp(dtr1,dtr2,"WITH"), m_MatchId(matchId)
    {};
    virtual ~CQWith() {};

    virtual BYTE GetMatchId() const;

    virtual BYTE SetMatchId(BYTE matchId);

    virtual bool Compile(CQueryCompiler *compiler);

    //-- ddcObject API
    virtual string jsonClass() { return "CQWith"; };
    virtual string jsonData();
    virtual string toString();
};

//------------------------------------------------------------
class CQWithout : public CQWith {
public:
    CQWithout(CQuery *dtr1=NULL, CQuery *dtr2=NULL, BYTE matchId=0)
        : CQWith(dtr1,dtr2,matchId)
    {
        m_OpName = "WITHOUT";
    };
    virtual ~CQWithout() {};

    virtual bool Compile(CQueryCompiler *compiler);
    virtual string jsonClass() { return "CQWithout"; };
};

//------------------------------------------------------------
class CQWithor : public CQWith {
public:
    CQWithor(CQuery *dtr1=NULL, CQuery *dtr2=NULL, BYTE matchId=0)
        : CQWith(dtr1,dtr2,matchId)
    {
        m_OpName = "WITHOR";
    };
    virtual ~CQWithor() {};

    virtual bool Compile(CQueryCompiler *compiler);
    virtual string jsonClass() { return "CQWithor"; };
};


//======================================================================
// CQToken: single-token queries

//------------------------------------------------------------
class CQToken : public CQAtomic {
public:
    string m_IndexName;

    string m_Value;

    BYTE m_MatchId;

public:
    CQToken(const string &indexName=string(""), const string &value=string(""), const BYTE matchId=0)
        : CQAtomic(value), m_IndexName(indexName), m_Value(value), m_MatchId(matchId)
    {};
    virtual ~CQToken() {};

    virtual BYTE GetMatchId() const;

    virtual BYTE SetMatchId(BYTE matchId);

    virtual bool Compile(CQueryCompiler *compiler);

    virtual bool Create(CQueryTokenNode *pNode);

    virtual const char *OperatorKey(void) const { return "_"; };

    string IndexName(const string& DefaultIndexName=string(""));

    string BreakName(const string& DefaultBreakName=string(""));

    virtual string IndexString(void);

    virtual string ValueString(void);

    virtual string MatchIdString(void);

    //-- ddcObject API & utilities
    virtual string toString(void);

    virtual string jsonValue(void);

    virtual string jsonClass() { return "CQToken"; };
    virtual string jsonData();
};

//------------------------------------------------------------
class CQTokExact : public CQToken {
public:
    CQTokExact(const string &indexName=string(""), const string &value=string(""))
        : CQToken(indexName,value)
    {};
    virtual ~CQTokExact() {};

    virtual const char *OperatorKey(void) const { return "@_"; };
    virtual string ValueString();

    virtual string jsonClass() { return "CQTokExact"; };
};

//------------------------------------------------------------
class CQTokAny : public CQToken {
public:
    CQTokAny(const string &indexName=string(""), const string &value=string("*"))
        : CQToken(indexName,value)
    {};
    virtual ~CQTokAny() {};

    virtual const char *OperatorKey(void) const { return "*"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokAny"; };
};


//------------------------------------------------------------
class CQTokAnchor : public CQToken {
public:
    int m_ValueInt;

public:
    CQTokAnchor(const string &indexName=string(""), const string &value=string(""))
        : CQToken(indexName,value)
    {
        m_ValueInt = strtol(value.c_str(), NULL, 0);
    };
    virtual ~CQTokAnchor() {};

    virtual const char *OperatorKey(void) const { return "."; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string IndexString(void);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokAnchor"; };
    virtual string jsonValue() { return Format("%d", m_ValueInt); };
};

//------------------------------------------------------------
class CQTokRegex : public CQToken {
public:
    bool m_bRegexNegated;
public:
    CQTokRegex(const string &indexName=string(""), const string &regex=string(""), bool negated=false)
        : CQToken(indexName,regex), m_bRegexNegated(negated)
    {};
    virtual ~CQTokRegex() {};

    virtual const char *OperatorKey(void) const { return "/_/"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokRegex"; };
};

//------------------------------------------------------------
class CQTokSet : public CQToken {
public:
    set<string> m_Values;

public:
    CQTokSet(const string &indexName=string(""), const string& rawValue=string(""), const set<string>& values=set<string>())
        : CQToken(indexName,rawValue), m_Values(values)
    {};
    virtual ~CQTokSet() {};

    virtual bool Create(CQueryTokenNode *pNode);
    virtual const char *OperatorKey(void) const { return "@_"; };

    string SetValueString(const set<string> &values);

    inline string SetValueString(void) { return SetValueString(m_Values); };

    inline string jsonValues(void) { return jsonArray(m_Values); };

    virtual string ValueString(void);

    virtual string jsonClass() { return "CQTokSet"; };
    virtual string jsonValue() { return jsonValues(); };
};

//------------------------------------------------------------
class CQTokInfl : public CQTokSet {
public:
    vector<string> m_Expanders;

    TxChain m_Txc;

public:
    CQTokInfl(const string &indexName=string(""), const string &value=string(""), const vector<string> expanders=vector<string>())
        : CQTokSet(indexName,value), m_Expanders(expanders), m_Txc("(CQTokInfl)")
    {};

    CQTokInfl(const string &indexName=string(""), const set<string> &values=set<string>(), const vector<string> expanders=vector<string>())
        : CQTokSet(indexName,string(""),values), m_Expanders(expanders), m_Txc("(CQTokInfl)")
    {};

    virtual ~CQTokInfl() {};


    TxChain& GetChain(void);

    virtual const char *OperatorKey(void) const { return "_"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString(void);

    virtual string ExpanderString(void);
    virtual string ExpanderJson(void);

    virtual string jsonClass() { return "CQTokInfl"; };
    virtual string jsonValue() { return CQToken::jsonValue(); };
    virtual string jsonData();
};

//------------------------------------------------------------
class CQTokSetInfl : public CQTokInfl {
public:
    set<string> m_RawValues;

public:
    CQTokSetInfl(const string &indexName=string(""), const set<string> &values=set<string>(), const vector<string> expanders=vector<string>())
        : CQTokInfl(indexName,values,expanders)
    { m_RawValues = m_Values; };

    virtual ~CQTokSetInfl() {};

    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString(void);

    virtual string jsonClass() { return "CQTokSetInfl"; };
    virtual string jsonValue() { return CQTokSet::jsonValue(); };
};

//------------------------------------------------------------
class CQTokPrefix : public CQToken {
public:
    CQTokPrefix(const string &indexName=string(""), const string &prefix=string(""))
        : CQToken(indexName,prefix)
    {};

    virtual ~CQTokPrefix() {};

    virtual const char *OperatorKey(void) const { return "/_/"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();

    virtual string jsonClass() { return "CQTokPrefix"; };
};

//------------------------------------------------------------
class CQTokSuffix : public CQToken {
public:
    CQTokSuffix(const string &indexName=string(""), const string &suffix=string(""))
        : CQToken(indexName,suffix)
    {};
    virtual ~CQTokSuffix() {};
    virtual const char *OperatorKey(void) const { return "/_/"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokSuffix"; };
};

//------------------------------------------------------------
class CQTokInfix : public CQToken {
public:
    CQTokInfix(const string &indexName=string(""), const string &infix=string(""))
        : CQToken(indexName,infix)
    {};
    virtual ~CQTokInfix() {};
    virtual const char *OperatorKey(void) const { return "/_/"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokInfix"; };
};

//------------------------------------------------------------
class CQTokPrefixSet : public CQTokSet {
public:
    CQTokPrefixSet(const string &indexName=string(""), const set<string> &prefixes=set<string>())
        : CQTokSet(indexName,"",prefixes)
    {};
    virtual ~CQTokPrefixSet() {};
    virtual const char *OperatorKey(void) const { return "/_/"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokPrefixSet"; };
};

//------------------------------------------------------------
class CQTokSuffixSet : public CQTokSet {
public:
    CQTokSuffixSet(const string &indexName=string(""), const set<string> &suffixes=set<string>())
        : CQTokSet(indexName,"",suffixes)
    {};
    virtual ~CQTokSuffixSet() {};
    virtual const char *OperatorKey(void) const { return "/_/"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokSuffixSet"; };
};

//------------------------------------------------------------
class CQTokInfixSet : public CQTokSet {
public:
    CQTokInfixSet(const string &indexName=string(""), const set<string> &infixes=set<string>())
        : CQTokSet(indexName,"",infixes)
    {};
    virtual ~CQTokInfixSet() {};
    virtual const char *OperatorKey(void) const { return "/_/"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokInfixSet"; };
};

//------------------------------------------------------------
class CQTokMorph : public CQToken {
public:
    vector<string> m_Items;

public:
    CQTokMorph(const string &indexName=string("MorphPattern"), const vector<string>& items=vector<string>())
        : CQToken(indexName), m_Items(items)
    { if (!m_Items.empty()) m_Value=m_Items[0]; };

    virtual ~CQTokMorph() {};

    void Append(const string &item) { m_Items.push_back(item); };

    virtual const char *OperatorKey(void) const { return "[_]"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();

    virtual string jsonClass() { return "CQTokMorph"; };
    virtual string jsonValue() { return jsonArray(m_Items); };
};

//------------------------------------------------------------
class CQTokLemma : public CQTokMorph {
public:
    CQTokLemma(const string &indexName=string("Lemma"), const string &value=string(""))
        : CQTokMorph(indexName,vector<string>(1,value))
    {};
    virtual ~CQTokLemma() {};

    virtual const char *OperatorKey(void) const { return "%_"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();

    virtual string jsonClass() { return "CQTokLemma"; };
    virtual string jsonValue() { return CQToken::jsonValue(); };
};

//------------------------------------------------------------
class CQTokThes : public CQToken {
public:
    CQTokThes(const string &indexName=string("Thes"), const string &value=string(""))
        : CQToken(indexName,value)
    {};
    virtual ~CQTokThes() {};

    virtual const char *OperatorKey(void) const { return ":{_}"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();

    virtual string jsonClass() { return "CQTokThes"; };
};

//------------------------------------------------------------
class CQTokChunk : public CQToken {
public:
    CQTokChunk(const string &indexName=string(""), const string &value=string(""))
        : CQToken(indexName,value)
    {};
    virtual ~CQTokChunk() {};

    virtual const char *OperatorKey(void) const { return "^_"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokChunk"; };
};

//------------------------------------------------------------
class CQTokFile : public CQToken {
public:
    CQTokFile(const string &indexName=string(""), const string &fileName=string(""))
        : CQToken(indexName,fileName)
    {};
    virtual ~CQTokFile() {};

    virtual const char *OperatorKey(void) const { return "<_"; };
    virtual bool Create(CQueryTokenNode *pNode);
    virtual string ValueString();
    virtual string jsonClass() { return "CQTokFile"; };
};


//======================================================================
// Misc

//------------------------------------------------------------
class CQNear : public CQNegatable {
public:
    CQuery *m_dtr1;

    CQuery *m_dtr2;

    CQuery *m_dtr3;

    BYTE    m_Dist;

public:
    CQNear(BYTE dist=1, CQuery *dtr1=NULL, CQuery *dtr2=NULL, CQuery *dtr3=NULL)
        : m_dtr1(dtr1), m_dtr2(dtr2), m_dtr3(dtr3), m_Dist(dist)
    {};

    virtual ~CQNear();

    virtual void ClearNode();

    virtual void Clear(bool deep=true);

    virtual ddcObjectList Children() const;

    virtual void DisownChildren();

    virtual BYTE GetMatchId() const;

    virtual BYTE SetMatchId(BYTE matchId);

    virtual bool Compile(CQueryCompiler *compiler);

    virtual string toString();

    virtual string jsonClass() { return "CQNear"; };
    virtual string jsonData();
};

//------------------------------------------------------------
class CQSeq : public CQAtomic {
public:
    vector<CQToken*> m_Items;

    vector<BYTE>  m_Dists;

    vector<BYTE>  m_DistOps;

public:
    CQSeq(const vector<CQToken*> &items, const vector<BYTE> &dists, const vector<BYTE> &distops)
        : m_Items(items), m_Dists(dists), m_DistOps(distops)
    {};

    CQSeq(CQToken *item)
        : m_Items(1,item)
    {};

    virtual ~CQSeq();

    virtual BYTE GetMatchId() const;

    virtual BYTE SetMatchId(BYTE matchId);

    virtual void ClearNode();

    virtual void Clear(bool deep=true);

    void Append(CQToken *nextItem, BYTE nextDist=0, BYTE nextDistOp='<');

    virtual bool Compile(CQueryCompiler *compiler);

    //-- ddcObject API
    virtual ddcObjectList Children() const;
    virtual void DisownChildren();
    virtual string toString();
    virtual string jsonClass() { return "CQSeq"; };
    virtual string jsonData();
};


#endif /* DDC_QUERY_H */

/*--- emacs style variables ---
 * Local Variables:
 *  mode: C++
 *  c-file-style: "ellemtel"
 *  c-basic-offset: 4
 *  tab-width: 8
 *  indent-tabs-mode: nil
 * End:
 */