selectClause.h

Go to the documentation of this file.

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

namespace ibis {
    class selectLexer;
    class selectParser;
}

class FASTBIT_CXX_DLLSPEC ibis::selectClause {
public:
    explicit selectClause(const char *cl=0);
    selectClause(const ibis::table::stringList&);
    ~selectClause();

    selectClause(const selectClause&);

    int parse(const char *cl);

    const char* getString(void) const {return clause_.c_str();}
    const char* operator*(void) const {return clause_.c_str();}

    bool empty() const {return atms_.empty();}

    void printDetails(std::ostream&) const;
    void print(std::ostream&) const;
    int find(const char*) const;

    typedef std::vector<ibis::math::term*> mathTerms;
    const mathTerms& getTerms() const {return xtms_;}
    const ibis::math::term* termExpr(unsigned i) const {return xtms_[i];}

    uint32_t numTerms() const {return xtms_.size();}
    const char* termName(unsigned i) const {return xnames_[i].c_str();}
    std::string termDescription(unsigned i) const;
    typedef std::map<const char*, const char*, ibis::lessi> nameMap;
    int getAliases(nameMap&) const;
    uint32_t numGroupbyKeys() const;
    int getGroupbyKeys(std::vector<std::string>& keys) const;

    enum AGREGADO {NIL_AGGR, AVG, CNT, MAX, MIN, SUM, DISTINCT,
                   VARPOP, VARSAMP, STDPOP, STDSAMP, MEDIAN};
    uint32_t aggSize() const {return atms_.size();}
    AGREGADO getAggregator(uint32_t i) const {return aggr_[i];}

    const ibis::math::term* aggExpr(unsigned i) const {return atms_[i];}
    const char* aggName(unsigned i) const {return names_[i].c_str();}
    std::string aggDescription(unsigned i) const {
        return aggDescription(aggr_[i], atms_[i]);}
    std::string aggDescription(AGREGADO, const ibis::math::term*) const;

    bool isSeparable() const;
    const char* isUnivariate() const;

    typedef std::map<std::string, unsigned> StringToInt;
    const StringToInt& getOrdered() const {return ordered_;}

    int verify(const ibis::part&) const;
    int verifySome(const std::vector<uint32_t>&, const ibis::part&) const;
    static int verifyTerm(const ibis::math::term&, const ibis::part&,
                          const ibis::selectClause* =0);

    void getNullMask(const ibis::part&, ibis::bitvector&) const;
    void clear();

    selectClause& operator=(const selectClause& rhs) {
        selectClause tmp(rhs);
        swap(tmp);
        return *this;
    }
    void swap(selectClause& rhs) {
        atms_.swap(rhs.atms_);
        aggr_.swap(rhs.aggr_);
        names_.swap(rhs.names_);
        ordered_.swap(rhs.ordered_);
        xtms_.swap(rhs.xtms_);
        xalias_.swap(rhs.xalias_);
        xnames_.swap(rhs.xnames_);
        clause_.swap(rhs.clause_);
    }

    // forward declaration
    class variable;
    friend class variable;

protected:
    mathTerms atms_;
    std::vector<AGREGADO> aggr_;
    std::vector<std::string> names_;
    StringToInt ordered_;
    mathTerms xtms_;
    StringToInt xalias_;
    std::vector<std::string> xnames_;

    std::string clause_;        

    ibis::selectLexer *lexer;   

    friend class ibis::selectParser;

    void fillNames();
    ibis::math::variable*
        addAgregado(ibis::selectClause::AGREGADO, ibis::math::term*);
    uint64_t decodeAName(const char*) const;
    void addTerm(ibis::math::term*, const std::string*);
    ibis::math::term* addRecursive(ibis::math::term*&);
    bool hasAggregation(const ibis::math::term *tm) const;

    typedef std::map<const char*, ibis::selectClause::variable*,
                     ibis::lessi> varMap;
    void gatherVariables(varMap &vmap, ibis::math::term* t) const;
}; // class ibis::selectClause

class ibis::selectClause::variable : public ibis::math::variable {
public:
    variable(const char* s, const ibis::selectClause *c)
        : ibis::math::variable(s), sc_(c) {};
    variable(const variable &v) : ibis::math::variable(v), sc_(v.sc_) {};
    virtual variable* dup() const {return new variable(*this);}
    virtual void print(std::ostream&) const;
    void updateReference(const ibis::selectClause *c) {sc_=c;}

private:
    const ibis::selectClause *sc_;

    variable();
}; // class ibis::selectClause::variable

namespace std {
    inline ostream& operator<<(ostream& out, const ibis::selectClause& sel) {
        sel.print(out);
        return out;
    } // std::operator<<
}
#endif