whereClause.h

Go to the documentation of this file.

// $Id$
// Author: John Wu <John.Wu at acm.org>
//      Lawrence Berkeley National Laboratory
// Copyright (c) 2007-2016 the Regents of the University of California
#ifndef IBIS_WHERECLAUSE_H
#define IBIS_WHERECLAUSE_H
#include "qExpr.h"

namespace ibis {
    class selectClause;
    class whereClause;
    class whereLexer;
    class whereParser;
}

class ibis::whereClause {
public:
    explicit whereClause(const char *cl=0);
    whereClause(const whereClause&);
    ~whereClause();

    int parse(const char *cl);
    void resetString() {
        if (expr_ != 0) {
            std::ostringstream oss;
            oss << *expr_;
            clause_ = oss.str();
        }
        else {
            clause_.clear();
        }
    }
    void setExpr(const ibis::qExpr *ex) {
        clause_.clear();
        delete expr_;
        expr_ = ex->dup();
    }
    void addExpr(const ibis::qExpr *);
    void addConditions(const char *);

    void clear() throw ();
    bool empty() const {return (expr_ == 0);}

    const char* getString(void) const {
        if (clause_.empty())
            return "";
        else
            return clause_.c_str();
    }
    const ibis::qExpr* getExpr(void) const {return expr_;}
    ibis::qExpr* getExpr(void) {return expr_;}
    void simplify() {ibis::qExpr::simplify(expr_);}
    int verify(const ibis::part& p0, const ibis::selectClause *sel=0) const;
    void getNullMask(const ibis::part&, ibis::bitvector&) const;

    ibis::qExpr* operator->() {return expr_;}
    const ibis::qExpr* operator->() const {return expr_;}

    whereClause& operator=(const whereClause&);
    void swap(whereClause& rhs) throw () {
        clause_.swap(rhs.clause_);
        ibis::qExpr* tmp = rhs.expr_;
        rhs.expr_ = expr_;
        expr_ = tmp;
    }

    static int verifyExpr(const ibis::qExpr*, const ibis::part&,
                          const ibis::selectClause *);
    static int verifyExpr(ibis::qExpr*&, const ibis::part&,
                          const ibis::selectClause *);
    static int removeAlias(ibis::qContinuousRange*&, const ibis::column*);

protected:
    std::string clause_;        
    ibis::qExpr *expr_;         

    void amplify(const ibis::part&);

private:
    ibis::whereLexer *lexer;    // hold a pointer for the parser

    friend class ibis::whereParser;
}; // class ibis::whereClause

namespace std {
    inline ostream& operator<<(ostream& out, const ibis::whereClause& wc) {
        if (!wc.empty())
            wc->print(out);
        return out;
    } // std::operator<<
}
#endif