QueryFilter.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_QFILTER_H
#define DDC_QFILTER_H

#include "ConcHolder.h"

class CQueryCompiler;       //-- forward decl
class CQueryOptions;        //-- forward decl
class CQCountKeyExprList;   //-- forward decl, for CQFPrune
class CQCount;              //-- forward decl, for CQFPrune

//======================================================================
// CQFilter

class CQFilter : public ddcObject {
public:
    //------------------------------------------------------------

    CQFilter()
    {};

    virtual ~CQFilter() {};
    
    virtual bool CheckSatisfiable(CQueryCompiler *compiler, CQueryOptions *options);

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);

    virtual CQFilter* Clone()
    { return new CQFilter(*this); };

    virtual HitSortEnum FilterType() const
    { return NoSort; };

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

    virtual string toString(void) { return string("#FILTER[?]"); };
    virtual string jsonClass(void) { return "CQFilter"; };
};

//======================================================================
// CQFSort

class CQFSort : public CQFilter {
public:
    CDDCFilterWithBounds m_Filter;

    std::string m_arg0;

    std::string m_arg1;

    std::string m_arg2;

public:
    CQFSort(HitSortEnum   ftype=NoSort,
            const string &arg0=string(""),
            const string &arg1=string(""),
            const string &arg2=string("")
        );

    CQFSort(HitSortEnum   ftype,
            const string &arg0,
            int           arg1i,
            int           arg2i
        );

    virtual ~CQFSort() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFSort(*this); };

    virtual HitSortEnum FilterType() const
    { return m_Filter.m_FilterType; };

    void SortBounds(void);

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);

    string ResolveAttributeName(CQueryCompiler *compiler, const string& attrName, bool allowBiblExpander=false);

    CFreeBiblIndex *GetBiblConstant(CQueryCompiler *compiler, const string &attrName, bool allowBiblExpander=true);

    //-- ddcObject API & utilities
    string argString(const string &arg) const;
    virtual string toString(void);
    virtual string jsonClass(void) { return "CQFSort"; };
    virtual string jsonMinMax(void);
    virtual string jsonType(void);
    virtual string jsonData(void) { return (this->jsonType()+","+this->jsonMinMax()); };
};

//======================================================================
// CQFRankSort

class CQFRankSort : public CQFSort {
public:
    CQFRankSort(HitSortEnum ftype=GreaterByRank)
        : CQFSort(ftype)
    {};
    virtual ~CQFRankSort() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFRankSort(*this); };

    virtual string jsonClass(void) { return "CQFRankSort"; };
    virtual string jsonData(void) { return this->jsonType(); };
};

//======================================================================
// CQFDateSort

class CQFDateSort : public CQFSort {
public:
    CQFDateSort(HitSortEnum ftype=LessByDate, const string &lb=string(""), const string &ub=string(""))
        : CQFSort(ftype,string(""),lb,ub)
    {};
    virtual ~CQFDateSort() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFDateSort(*this); };
  
    static int Str2Date(const std::string &datestr, int onEmpty=0);

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);
    virtual string jsonClass(void) { return "CQFDateSort"; };
};

//======================================================================
// CQFSizeSort

class CQFSizeSort : public CQFSort {
public:
    CQFSizeSort(HitSortEnum ftype=LessBySize, const string &lb=string(""), const string &ub=string(""))
        : CQFSort(ftype,string(""),lb,ub)
    {};

    CQFSizeSort(HitSortEnum ftype=LessBySize, int lb=INT_MIN, int ub=INT_MAX);

    virtual ~CQFSizeSort() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFSizeSort(*this); };

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);
    virtual string jsonClass(void) { return "CQFSizeSort"; };
};

//======================================================================
// CQFRandomSort

class CQFRandomSort : public CQFSort {
public:
    CQFRandomSort(const string &seed0=string(""))
        : CQFSort(RandomSort,string(""),seed0)
    {};

    CQFRandomSort(int seed0);

    virtual ~CQFRandomSort() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFRandomSort(*this); };

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);
    virtual string jsonClass(void) { return "CQFRandomSort"; };
    virtual string jsonData(void) { return (this->jsonType()+",\"Seed\":"+jsonStr(m_arg1)); };
};

//======================================================================
// CQFBiblSort

class CQFBiblSort : public CQFSort {
public:
    CQFBiblSort(HitSortEnum ftype=LessByFreeBiblField,
                const string &field=string(""),
                const string &lb=string(""),
                const string &ub=string(""))
        : CQFSort(ftype,field,lb,ub)
    {};

    virtual ~CQFBiblSort() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFBiblSort(*this); };

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);

    virtual string toString(void);
    virtual string jsonClass(void) { return "CQFBiblSort"; };
    virtual string jsonData(void);
    virtual string jsonMinMax(void);
};

//======================================================================
// CQFContextSort (formerly CQFBigramSort)

class CQFContextSort : public CQFSort {
public:
    CQFContextSort(HitSortEnum ftype=LessByMiddleContext,
                   const string &field=string(""),
                   int matchid=0,
                   int offset=0,
                   const string &lb=string(""),
                   const string &ub=string(""))
        : CQFSort(ftype,field,lb,ub)
    {
        m_Filter.m_ContextMatchId = matchid;
        m_Filter.m_ContextOffset = offset;
    };

    virtual ~CQFContextSort() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFContextSort(*this); };

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);

    virtual string toString(void);
    virtual string jsonClass(void) { return "CQFContextSort"; };
    virtual string jsonData(void);
};

//======================================================================
// CQFHasField (abstract)

class CQFHasField : public CQFSort {
public:
    bool m_Negated;

public:
    CQFHasField(const std::string &field, const std::string &val=string(""), bool isNegated=false)
        : CQFSort(NoSort, field, val, string("")), m_Negated(isNegated)
    {};

    virtual ~CQFHasField() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFHasField(*this); };

    virtual void Negate(void);

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);

    virtual string valueString(void);

    virtual string toString(void);

    virtual string jsonClass(void) { return "CQFHasField"; };
    virtual string jsonFieldValue(void) { return jsonStr(m_arg1); };
    virtual string jsonMinMax(void);
};


//======================================================================
// CQFHasFieldValue

class CQFHasFieldValue : public CQFHasField {
public:
    CQFHasFieldValue(const std::string &field, const std::string &val=string(""), bool isNegated=false)
        : CQFHasField(field, val, isNegated)
    {};

    virtual ~CQFHasFieldValue() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFHasFieldValue(*this); };

    virtual bool CheckSatisfiable(CQueryCompiler *compiler, CQueryOptions *options);
    
    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);
    virtual string jsonClass(void) { return "CQFHasFieldValue"; };
};

//======================================================================
// CQFHasFieldRegex

class CQFHasFieldRegex : public CQFHasField {
public:
    std::string m_Regex;

public:
    CQFHasFieldRegex(const std::string &field, const std::string &val=string(""), bool isNegated=false)
        : CQFHasField(field, val, isNegated), m_Regex(val)
    {};

    virtual ~CQFHasFieldRegex() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFHasFieldRegex(*this); };

    virtual bool CheckSatisfiable(CQueryCompiler *compiler, CQueryOptions *options);

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);

    virtual string valueString(void);
    virtual string jsonClass(void) { return "CQFHasFieldRegex"; };
};

//======================================================================
// CQFHasFieldPrefix

class CQFHasFieldPrefix : public CQFHasFieldRegex {
public:
    CQFHasFieldPrefix(const std::string &field, const std::string &val=string(""), bool isNegated=false)
        : CQFHasFieldRegex(field, val, isNegated)
    {
        m_Regex = std::string("^") + escapeRegex(val);
    };

    virtual ~CQFHasFieldPrefix() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFHasFieldPrefix(*this); };
  
    virtual string valueString(void);
    virtual string jsonClass(void) { return "CQFHasFieldPrefix"; };
};

//======================================================================
// CQFHasFieldSuffix

class CQFHasFieldSuffix : public CQFHasFieldRegex {
public:
    CQFHasFieldSuffix(const std::string &field, const std::string &val=string(""), bool isNegated=false)
        : CQFHasFieldRegex(field, val, isNegated)
    {
        m_Regex = escapeRegex(val) + "$";
    };

    virtual ~CQFHasFieldSuffix() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFHasFieldSuffix(*this); };
  
    virtual string valueString(void);
    virtual string jsonClass(void) { return "CQFHasFieldSuffix"; };
};

//======================================================================
// CQFHasFieldInfix

class CQFHasFieldInfix : public CQFHasFieldRegex {
public:
    CQFHasFieldInfix(const std::string &field, const std::string &val=string(""), bool isNegated=false)
        : CQFHasFieldRegex(field, val, isNegated)
    {
        m_Regex = escapeRegex(val);
    };

    virtual ~CQFHasFieldInfix() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFHasFieldInfix(*this); };
  
    virtual string valueString(void);
    virtual string jsonClass(void) { return "CQFHasFieldInfix"; };
};

//======================================================================
// CQFHasFieldSet

class CQFHasFieldSet : public CQFHasField {
public:
    std::set<std::string> m_Values;

public:
    CQFHasFieldSet(const std::string &field, const set<string>& vals=set<string>(), bool isNegated=false)
        : CQFHasField(field, string("{}"), isNegated), m_Values(vals)
    {};

    virtual ~CQFHasFieldSet() {};

    virtual CQFilter* Clone()
    { return (CQFilter*)new CQFHasFieldSet(*this); };

    virtual bool CheckSatisfiable(CQueryCompiler *compiler, CQueryOptions *options);

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);

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

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

    virtual string valueString(void);

    virtual string jsonClass(void) { return "CQFHasFieldSet"; };
    virtual string jsonFieldValue(void);
};

//======================================================================
// CQFPrune

class CQFPrune : public CQFSort {
public:
    size_t m_limit;

    CQCountKeyExprList *m_keys;

    CCountMap m_Counts;

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

    CQFPrune(HitSortEnum ftype=LessByPruneKey, size_t Limit=0, CQCountKeyExprList* Keys=NULL);

    virtual ~CQFPrune();

    virtual CQFilter* Clone();

    virtual bool Compile(CQueryCompiler *compiler, CQueryOptions *options);

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

    virtual string toString(void);

    virtual string jsonClass(void) { return "CQFPrune"; };
    virtual string jsonData(void);

    virtual ddcObjectList Children() const;
    virtual void DisownChildren();

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

    void PruneHitsIndex(const CQuery *qRoot, vector<size_t>& PeriodHitsIndex);
};

#endif /* DDC_QFILTER_H */

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