QueryCompiler.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/>.
//
#if !defined(__DDC_QUERY_COMPILER_H_)
#define __DDC_QUERY_COMPILER_H_

#include <list>

#include "QueryNode.h"    // v1.x query-node API
#include "QueryFilter.h"  // v2.x query-filter API
#include "Query.h"        // v2.x query-node API (wrapper)
#include "QCount.h"       // v2.0.23+ count-query API

#include "yyQParser.h"
//#include "yyQLexer.h" //-- included from yyQParser.h (2017-03-01)

#undef yyFlexLexer
#define yyFlexLexer yyqLexer
#include "FlexLexer.h"


//-- moo: re-working parse-tree API
#define PARSER_USE_OLD_API
#undef PARSER_USE_OLD_API

class CQueryCompiler : public ddcObject, virtual public yyqLexer
{
public:
    //--------------------------------------------------------------
    // constants

    static const size_t m_MaxContextSentencesCount = 5;

public:
    //--------------------------------------------------------------
    // top-level query properties

    const CConcHolder* m_pHolder;

    CQuery* m_pQuery;

    CQueryOptions m_qOptions;

    size_t m_Limit;

    bool m_bSatisfiable;

    //--------------------------------------------------------------
    // temporaries

    CQCountKeyExprList m_qCountKeys;

    size_t m_qCountSample;

    size_t m_qCountLimit;

    HitSortEnum m_qCountSort;

    string m_qCountLo;

    string m_qCountHi;

    vector<string> m_IndexTuple;

    set<string> m_WordSet;

    vector<string> m_Expanders;

    vector<string> m_MorphItems;

    string m_FilterField;

    string m_FilterLB;

    string m_FilterUB;

    BYTE m_FilterMatchId;

    int m_FilterOffset;

    string m_RegexPattern;

    string m_RegexReplacement;

    string m_RegexModifiers;

    //--------------------------------------------------------------
    // administrivia

    int m_CurrentNodeIndex;

    vector<CQuery*> m_Queries;

    list<string> m_Labels;

    bool m_KeepLexerComments;

public:
    CQueryCompiler(const CConcHolder* pHolder=NULL);

    virtual ~CQueryCompiler();

    void CleanParser();

    int yyqlex (void* valp);

    string* newString(const string &s=string(""));

    string* newRegex(const string &pattern, const string &modifiers=string(""), bool isMatch=true);

    inline const char* yytext() const { return YYText(); };

    inline int yyleng() const { return YYLeng(); };

    inline string yystring() const { return string(YYText(),YYLeng()); };

    void yybegin(int new_state);

    void DeleteTree();

    bool ParseQuery(const string &QueryStr);

    bool CompileFilters();

    bool CheckSatisfiable(CQuery* query);

    bool Compile(CQuery *query);

    bool Evaluate(CQuery *query);
    
    inline bool CheckSatisfiable()
    { return CheckSatisfiable(m_pQuery); };

    inline bool Compile()
    { return Compile(m_pQuery); };

    inline bool Evaluate()
    { return Evaluate(m_pQuery); };

    int GetNewNodeIndex();

    size_t  GetNodeIndicesCount() const;

    CQuery* SetQuery(CQuery* qp);

    inline CQuery* PushQuery(CQuery* qp) { m_Queries.push_back(qp); return qp; };

    CQCount* PushCountQuery(CQuery *qConditions);

    CQKeys* PushKeysQuery(CQCount *qCount);

    CQFPrune* newPruneFilter(HitSortEnum ftype, const string& limitStr="-1");
    
    void SetFilterBounds(const string& lb="", const string& ub="");

    void SetFilterKey(const string &field="", BYTE matchid=0, int offset=INT_MIN);

    string QueryToString(void);

    string QueryToJson(void);

    void barf(const std::string &msg) const;  //throw(CExpc)

    void barf(const char *fmt, ...) const; //throw(CExpc)

    void yybarf(const char *yymsg) const; //throw(CExpc)

    //-- ddcObject API
    virtual ddcObjectList Children() const;
    virtual void DisownChildren();
    virtual string jsonClass() { return "CQueryCompiler"; };
    virtual string jsonData()  { return string("\"Query\":" + jsonStr(m_pQuery)); };
};

#endif

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