CLucene - a full-featured, c++ search engine
API Documentation

---

QueryParser.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
* 
* Distributable under the terms of either the Apache License (Version 2.0) or 
* the GNU Lesser General Public License, as specified in the COPYING file.
------------------------------------------------------------------------------*/
#ifndef _lucene_queryParser_QueryParser_
#define _lucene_queryParser_QueryParser_


//#include "CLucene/analysis/AnalysisHeader.h"
CL_CLASS_DEF(util,Reader)
//#include "CLucene/search/SearchHeader.h"
CL_CLASS_DEF(index,Term)
CL_CLASS_DEF(analysis,Analyzer)
CL_CLASS_DEF(search,Query)
CL_CLASS_DEF(search,BooleanClause)
CL_CLASS_DEF(queryParser,TokenList)

#include <vector>

//#include "TokenList.h"
#include "QueryToken.h"
//#include "QueryParserBase.h"
//#include "Lexer.h"

CL_NS_DEF(queryParser)



class CLUCENE_EXPORT QueryParserBase:LUCENE_BASE
{
protected:
        /* The actual operator the parser uses to combine query terms */
        int defaultOperator;
        int32_t phraseSlop;

        bool lowercaseExpandedTerms;

        LUCENE_STATIC_CONSTANT(int,  CONJ_NONE=0);
        LUCENE_STATIC_CONSTANT(int,  CONJ_AND=1);
        LUCENE_STATIC_CONSTANT(int,  CONJ_OR=2);

        LUCENE_STATIC_CONSTANT(int,  MOD_NONE=0);
        LUCENE_STATIC_CONSTANT(int,  MOD_NOT=10);
        LUCENE_STATIC_CONSTANT(int,  MOD_REQ=11);

        CL_NS(analysis)::Analyzer* analyzer;
        
public:
        QueryParserBase(CL_NS(analysis)::Analyzer* analyzer);
        ~QueryParserBase();

        void  setLowercaseExpandedTerms(bool lowercaseExpandedTerms);

        bool getLowercaseExpandedTerms() const;

        //values used for setOperator
        LUCENE_STATIC_CONSTANT(int,  OR_OPERATOR=0);
        LUCENE_STATIC_CONSTANT(int,  AND_OPERATOR=1);

        void setDefaultOperator(int oper);
        int getDefaultOperator() const;

        //public so that the lexer can call this
        virtual void throwParserException(const TCHAR* message, TCHAR ch, int32_t col, int32_t line );

        void setPhraseSlop(int phraseSlop) { this->phraseSlop = phraseSlop; }

        int getPhraseSlop() { return phraseSlop; }

protected:

        void discardEscapeChar(TCHAR* token) const;

    //Analyzes the expanded term termStr with the StandardFilter and the LowerCaseFilter.
    TCHAR* AnalyzeExpandedTerm(const TCHAR* field, TCHAR* termStr);

        // Adds the next parsed clause.
        virtual void AddClause(std::vector<CL_NS(search)::BooleanClause*>& clauses, int32_t conj, int32_t mods, CL_NS(search)::Query* q);

        virtual CL_NS(search)::Query* GetFieldQuery(const TCHAR* field, TCHAR* queryText);

        virtual CL_NS(search)::Query* GetFieldQuery(const TCHAR* field, TCHAR* queryText, int32_t slop);

    virtual CL_NS(search)::Query* GetPrefixQuery(const TCHAR* field, TCHAR* termStr);
        
    virtual CL_NS(search)::Query* GetWildcardQuery(const TCHAR* field, TCHAR* termStr);

    virtual CL_NS(search)::Query* GetFuzzyQuery(const TCHAR* field, TCHAR* termStr);

    virtual CL_NS(search)::Query* GetBooleanQuery(std::vector<CL_NS(search)::BooleanClause*>& clauses);
        virtual CL_NS(search)::Query* GetBooleanQuery(std::vector<CL_NS(search)::BooleanClause*>& clauses, bool disableCoord );

        virtual CL_NS(search)::Query* GetRangeQuery(const TCHAR* field, TCHAR* part1, TCHAR* part2, bool inclusive);
        virtual CL_NS(search)::Query* ParseRangeQuery(const TCHAR* field, TCHAR* str, bool inclusive);
};

class CLUCENE_EXPORT QueryParser : public QueryParserBase
{
private:
        const TCHAR* field;
        TokenList* tokens;
public:
        QueryParser(const TCHAR* field, CL_NS(analysis)::Analyzer* analyzer);
        ~QueryParser();

        virtual CL_NS(search)::Query* parse(const TCHAR* query);

        virtual CL_NS(search)::Query* parse(CL_NS(util)::Reader* reader);

        static CL_NS(search)::Query* parse(const TCHAR* query, const TCHAR* field, CL_NS(analysis)::Analyzer* analyzer);

        CL_NS(analysis)::Analyzer* getAnalyzer() { return analyzer; }

        const TCHAR* getField();
        
        //deprecated functions
        _CL_DEPRECATED( setLowercaseExpandedTerms ) void  setLowercaseWildcardTerms(bool lowercaseWildcardTerms);
        _CL_DEPRECATED( getLowercaseExpandedTerms ) bool  getLowercaseWildcardTerms() const;
protected:
        //these functions may be defined under certain compilation conditions.
        //note that this functionality is deprecated, you should create your own queryparser
        //if you want to remove this functionality...it will be removed... be warned!
#ifdef NO_PREFIX_QUERY
        virtual CL_NS(search)::Query* GetPrefixQuery(const TCHAR* field,const TCHAR* termStr){ return NULL; }
#endif
#ifdef NO_FUZZY_QUERY
    virtual CL_NS(search)::Query* GetFuzzyQuery(const TCHAR* field,const TCHAR* termStr){ return NULL; }
#endif
#ifdef NO_RANGE_QUERY
        virtual CL_NS(search)::Query* GetRangeQuery(const TCHAR* field, const TCHAR* part1, const TCHAR* part2, bool inclusive) { return NULL; }
#endif
#ifdef NO_WILDCARD_QUERY
        virtual CL_NS(search)::Query* GetWildcardQuery(const TCHAR* field, TCHAR* termStr) { return NULL; }
#endif
private:
        int32_t MatchConjunction();

        int32_t MatchModifier();

        CL_NS(search)::Query* MatchQuery(const TCHAR* field);

        CL_NS(search)::Query* MatchClause(const TCHAR* field);

        CL_NS(search)::Query* MatchTerm(const TCHAR* field);

        QueryToken* MatchQueryToken(QueryToken::Types expectedType);

        void ExtractAndDeleteToken(void);
};
CL_NS_END
#endif

---

clucene.sourceforge.net