QCount.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_QCOUNT_H
#define DDC_QCOUNT_H

#include "../ConcordLib/Query.h"

//======================================================================
//typedef vector<string>        CQCountByList;

const size_t DDCDefaultCountSampleSize = (size_t)-1;

// workaround for "error: overriding ‘virtual std::invalid_argument::~invalid_argument() throw ()’" under g++-5.4.0 / ubuntu 16.04.6
#ifndef _GLIBCXX_USE_NOEXCEPT
# define _GLIBCXX_USE_NOEXCEPT
#endif

class CQCountKeyBadOccurrence : public invalid_argument
{
public:
    CQCountKeyBadOccurrence(const string& what_arg)
        : invalid_argument(what_arg)
    {};
    virtual ~CQCountKeyBadOccurrence() _GLIBCXX_USE_NOEXCEPT {};
};

//==============================================================================
// Hit sizes

//==============================================================================
// CQCountKeyExpr and subclasses

//----------------------------------------------------------------------
class CQCountKeyExpr : public CQuery
{
public:
    CQCountKeyExpr(const string& label="")
        : CQuery(label)
    {};

    //virtual void Clear(bool deep=true);

    virtual ~CQCountKeyExpr()
    {};

    virtual bool CanCountByFile() const { return true; };

    virtual bool Compile(CQueryCompiler *compiler);

    virtual string& Evaluate(const CHit &Hit);

    virtual string toString() { return m_Label; };

    string jsonClass() { return "CQCountKeyExpr"; };

    string jsonData() { return "\"label\":" + jsonStr(m_Label); };
};

//----------------------------------------------------------------------
class CQCountKeyExprConstant : public CQCountKeyExpr {
public:
    CQCountKeyExprConstant(const string &label="*") : CQCountKeyExpr(label) {};
    virtual ~CQCountKeyExprConstant() {};
    virtual string& Evaluate(const CHit &Hit) { return m_Label; };
    virtual string jsonClass() { return "CQCountKeyExprConstant"; };
    virtual string toString() { return string("@'") + escapeChars(m_Label,"\\'") + "'"; };
};

//----------------------------------------------------------------------
class CQCountKeyExprMeta : public CQCountKeyExpr {
public:
    DWORD  m_CurFile;

    string m_CurKey;

public:
    CQCountKeyExprMeta(const string &label="*") : CQCountKeyExpr(label), m_CurFile(-1), m_CurKey("") {};
    virtual ~CQCountKeyExprMeta() {};
};

//----------------------------------------------------------------------
class CQCountKeyExprFileId : public CQCountKeyExprMeta {
private:
    char buf[16];
public:
    CQCountKeyExprFileId(const string &label="fileid") : CQCountKeyExprMeta(label) {};
    virtual ~CQCountKeyExprFileId() {};
    virtual string& Evaluate(const CHit &Hit);
    virtual string jsonClass() { return "CQCountKeyExprFileId"; };
};

//----------------------------------------------------------------------
class CQCountKeyExprIndexed : public CQCountKeyExprMeta {
public:
    class CConcordance* m_pConcordance;
public:
    CQCountKeyExprIndexed(const string &label="file") : CQCountKeyExprMeta(label) {};
    virtual ~CQCountKeyExprIndexed() {};
    virtual bool Compile(CQueryCompiler *compiler);
    virtual string jsonClass() { return "CQCountKeyExprIndexed"; };
};

//----------------------------------------------------------------------
class CQCountKeyExprFileName : public CQCountKeyExprIndexed {
public:
    CQCountKeyExprFileName(const string &label="filename") : CQCountKeyExprIndexed(label) {};
    virtual ~CQCountKeyExprFileName() {};
    virtual string& Evaluate(const CHit &Hit);
    virtual string jsonClass() { return "CQCountKeyExprFileName"; };
};

//----------------------------------------------------------------------
class CQCountKeyExprDate : public CQCountKeyExprIndexed
{
public:
    const ddcDateVector *m_pDates;
      signed int         m_year;
    unsigned int         m_month;
    unsigned int         m_day;
    char                 buf[16];

public:
    CQCountKeyExprDate(const string &label="date") : CQCountKeyExprIndexed(label), m_pDates(NULL) {};
    virtual ~CQCountKeyExprDate() {};
    virtual bool Compile(CQueryCompiler *compiler);
    virtual string& Evaluate(const CHit &Hit);
    virtual string jsonClass() { return "CQCountKeyExprDate"; };
};

//----------------------------------------------------------------------
class CQCountKeyExprDateSlice : public CQCountKeyExprDate
{
public:
    unsigned int m_slice;
public:
    CQCountKeyExprDateSlice(const string &label="date", int slice=1) : CQCountKeyExprDate(label), m_slice(slice) {};
    virtual ~CQCountKeyExprDateSlice() {};
    virtual bool Compile(CQueryCompiler *compiler);
    virtual string& Evaluate(const CHit &Hit);
    virtual string toString() { return m_Label + Format("/%d",m_slice); };
    virtual string jsonClass() { return "CQCountKeyExprDateSlice"; };
    virtual string jsonData() { return CQCountKeyExprDate::jsonData() + Format(",\"slice\":%d",m_slice); };
};

//----------------------------------------------------------------------
class CQCountKeyExprBibl : public CQCountKeyExprIndexed
{
public:
    const CFreeBiblIndexInterface *m_Bibl;
public:
    CQCountKeyExprBibl(const string &attrName="") : CQCountKeyExprIndexed(attrName) {};
    virtual ~CQCountKeyExprBibl() {};
    virtual bool Compile(CQueryCompiler *compiler);
    virtual string& Evaluate(const CHit &Hit);
    virtual string jsonClass() { return "CQCountKeyExprBibl"; };
    virtual string toString() { return string("'") + escapeChars(m_Label,"\\'") + "'"; };
};

//----------------------------------------------------------------------
class CQCountKeyExprRegex : public CQCountKeyExprIndexed
{
public:
    CQCountKeyExpr *m_Src;
    string      m_Pattern;
    string      m_Replacement;
    string      m_Modifiers;
    bool        isGlobal;
    RML_RE     *m_Regex;

public:
    CQCountKeyExprRegex(CQCountKeyExpr *src, const string& pattern, const string &replacement, const string& modifiers=string(""))
        : CQCountKeyExprIndexed("regex"), m_Src(src), m_Pattern(pattern), m_Replacement(replacement), m_Modifiers(modifiers), isGlobal(false), m_Regex(NULL) {};
    virtual ~CQCountKeyExprRegex();
    virtual void DisownChildren();
    virtual bool CanCountByFile() const { return m_Src->CanCountByFile(); };
    virtual bool Compile(CQueryCompiler *compiler);
    virtual string& Evaluate(const CHit &Hit);
    inline void EvaluateRegex(const CHit &Hit, const string& srcKey)
    {
        m_CurKey = srcKey;
        if (isGlobal)
            m_Regex->GlobalReplace(m_Replacement, &m_CurKey);
        else
            m_Regex->Replace(m_Replacement, &m_CurKey);
        m_CurFile = Hit.m_FileNo;
    };
  
    //-- ddcObject API
    virtual ddcObjectList Children() const;
    virtual string toString();
    virtual string jsonClass() { return "CQCountKeyExprRegex"; };
    virtual string jsonData();
};

//----------------------------------------------------------------------
class CQCountKeyExprToken : public CQCountKeyExprIndexed
{
public:
    string m_IndexName;

    BYTE   m_MatchId;

    int    m_Offset;

    CStringIndexSet *m_pIndex;

public:
    CQCountKeyExprToken(const string &IndexName="Token", BYTE MatchId=0, int Offset=0)
        : CQCountKeyExprIndexed("token"), m_IndexName(IndexName), m_MatchId(MatchId), m_Offset(Offset), m_pIndex(NULL)
    {};
    virtual ~CQCountKeyExprToken() {};
    virtual BYTE GetMatchId() const { return m_MatchId; };
    virtual BYTE SetMatchId(BYTE matchId) { return m_MatchId = matchId; };
    virtual bool CanCountByFile() const { return false; };
    virtual bool Compile(CQueryCompiler *compiler);
    virtual string& Evaluate(const CHit &Hit);
    virtual string toString();
    virtual string jsonClass() { return "CQCountKeyExprToken"; };
    virtual string jsonData();
};

//----------------------------------------------------------------------
// count-key expr: list
class CQCountKeyExprList : public CQCountKeyExpr
{
public:
    vector<CQCountKeyExpr*> m_Exprs;

    string m_Key;

public:
    CQCountKeyExprList() : m_Key("") {};

    CQCountKeyExprList(const CQCountKeyExprList &src)
        : m_Exprs(src.m_Exprs), m_Key(src.m_Key)
    {};

    virtual ~CQCountKeyExprList();

    virtual void Clear();

    inline bool empty() const { return m_Exprs.empty(); };

    void PushKey(CQCountKeyExpr *expr)
    { m_Exprs.push_back(expr); };

    virtual bool CanCountByFile() const;

    virtual BYTE GetMatchId() const;

    virtual bool Compile(CQueryCompiler *compiler);
    virtual string& Evaluate(const CHit &Hit);

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

};

//======================================================================
class CQCount : public CQuery {
public:
    CQuery *m_dtr;

    size_t m_sample;

    HitSortEnum m_sort;

    string m_lo;

    string m_hi;

    CQCountKeyExprList* m_keys;

    CCountMap m_Counts;

    size_t m_CountSample;

public:
    CQCount(CQuery *dtr_=NULL, CQCountKeyExprList* keys_=NULL, size_t sample_=DDCDefaultCountSampleSize, HitSortEnum sort_=NoSort, string lb="", string ub="")
        : CQuery("count"),
          m_dtr(dtr_),
          m_sample(sample_),
          m_sort(sort_),
          m_keys(keys_),
          m_lo(lb),
          m_hi(ub),
          m_CountSample(0)
    {
        if (sample_==0) m_sample = DDCDefaultCountSampleSize;
    };

    virtual ~CQCount(void);

public:
    virtual BYTE GetMatchId() const;

    bool CompileLocal(CQueryCompiler *compiler, bool compileDtr=true, bool compileKeys=true);

    virtual bool CheckSatisfiable(CQueryCompiler *compiler);

    virtual bool Compile(CQueryCompiler *compiler);

    virtual void Evaluate();

    virtual bool CanCountUniversal();

    virtual bool CanCountByFile() const;
    
    virtual void CountUniversal(CQueryResult &Result, size_t Limit);

    virtual void CountLocal(CQueryResult &Result, size_t Limit);

    virtual void ConvertCountsToHits(CQueryResult &Result, size_t Limit);

    virtual string toString();
    //virtual string optionsToString() { return ""; };
    virtual string countOptionsToString();

    virtual string jsonClass() { return "CQCount"; };
    virtual string jsonData();
    //virtual string optionsToJson() { return "null"; };

    virtual void ClearNode();

    virtual void Clear(bool deep=true);

    //-- ddcObject API
    virtual ddcObjectList Children() const;
    virtual void DisownChildren();
};


//======================================================================
//======================================================================
class CQKeys : public CQuery {
public:
    typedef set< vector<string> > StringTupleSet;
  
public:
    CQCount *m_qCount;

    size_t m_CountLimit;

    vector<string> m_IndexNames;

    BYTE   m_MatchId;

    vector<CQTokSet*> m_dtrs;

    CQuery *m_proxy;

    // pseudo-private: all value tuples
    //StringTupleSet m_tuples;

public:
    CQKeys(CQCount *qCount=NULL, size_t CountLimit=DDCDefaultCountSampleSize)
        : CQuery("keys"), m_qCount(qCount), m_CountLimit(CountLimit), m_MatchId(0), m_proxy(NULL)
    {};

    CQKeys(CQCount *qCount, size_t CountLimit, const vector<string>& IndexNames)
        : CQuery("keys"), m_qCount(qCount), m_CountLimit(CountLimit), m_IndexNames(IndexNames), m_MatchId(0), m_proxy(NULL)
    {};

    virtual ~CQKeys(void);

public:
    virtual bool Compile(CQueryCompiler *compiler);

    virtual void Evaluate();

    virtual BYTE GetMatchId() const;

    virtual BYTE SetMatchId(BYTE matchId)
    { return m_MatchId = matchId; };

    virtual string toString();

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

    virtual void ClearNode();

    virtual void Clear(bool deep=true);

    //-- ddcObject API
    virtual ddcObjectList Children() const;
    virtual void DisownChildren();
};


//======================================================================
// functions

void GenerateCountString(string &ResultStr, DDCFormatTypeEnum fmt, const string& key, size_t count);

inline void GenerateCountString(string &ResultStr, DDCFormatTypeEnum fmt, const CHit &hit)
{ GenerateCountString(ResultStr, fmt, hit.m_SortKey.s, hit.m_Value.m_Count); };


#endif /* DDC_QCOUNT_H */

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