selectClause.h
Go to the documentation of this file.
00001 // $Id$
00002 // Author: John Wu <John.Wu at acm.org>
00003 //      Lawrence Berkeley National Laboratory
00004 // Copyright 2007-2011 the Regents of the University of California
00008 #ifndef IBIS_SELECTCLAUSE_H
00009 #define IBIS_SELECTCLAUSE_H
00010 #include "qExpr.h"
00011 #include "table.h"
00012 
00013 namespace ibis {
00014     class selectLexer;
00015     class selectParser;
00016 }
00017 
00086 class FASTBIT_CXX_DLLSPEC ibis::selectClause {
00087 public:
00089     explicit selectClause(const char *cl=0);
00091     selectClause(const ibis::table::stringList&);
00092     ~selectClause();
00093 
00095     selectClause(const selectClause&);
00096 
00098     int parse(const char *cl);
00099 
00101     const char* getString(void) const {return clause_.c_str();}
00103     const char* operator*(void) const {return clause_.c_str();}
00104 
00106     bool empty() const {return atms_.empty();}
00107 
00108     void print(std::ostream&) const;
00109     void printDetails(std::ostream&) const;
00110     int find(const char*) const;
00111 
00116     typedef std::vector<ibis::math::term*> mathTerms;
00118     const mathTerms& getTerms() const {return xtms_;}
00120     const ibis::math::term* termExpr(unsigned i) const {return xtms_[i];}
00121 
00123     uint32_t numTerms() const {return xtms_.size();}
00127     const char* termName(unsigned i) const {return xnames_[i].c_str();}
00128     std::string termDescription(unsigned i) const;
00129     typedef std::map<const char*, const char*, ibis::lessi> nameMap;
00130     int getAliases(nameMap&) const;
00131     uint32_t numGroupbyKeys() const;
00132     int getGroupbyKeys(std::vector<std::string>& keys) const;
00134 
00138     uint32_t aggSize() const {return atms_.size();}
00140     const ibis::math::term* aggExpr(unsigned i) const {return atms_[i];}
00143     const char* aggName(unsigned i) const {return names_[i].c_str();}
00144     std::string aggDescription(unsigned i) const;
00145 
00147     enum AGREGADO {NIL_AGGR, AVG, CNT, MAX, MIN, SUM, DISTINCT,
00148                    VARPOP, VARSAMP, STDPOP, STDSAMP, MEDIAN};
00150     AGREGADO getAggregator(uint32_t i) const {return aggr_[i];}
00151 
00152     typedef std::map<std::string, unsigned> StringToInt;
00153     const StringToInt& getOrdered() const {return ordered_;}
00155 
00156     int verify(const ibis::part&) const;
00157     int verifySome(const std::vector<uint32_t>&, const ibis::part&) const;
00158     static int verifyTerm(const ibis::math::term&, const ibis::part&,
00159                           const ibis::selectClause* =0);
00160 
00161     void getNullMask(const ibis::part&, ibis::bitvector&) const;
00162     void clear();
00163 
00165     selectClause& operator=(const selectClause& rhs) {
00166         selectClause tmp(rhs);
00167         swap(tmp);
00168         return *this;
00169     }
00171     void swap(selectClause& rhs) {
00172         atms_.swap(rhs.atms_);
00173         aggr_.swap(rhs.aggr_);
00174         names_.swap(rhs.names_);
00175         ordered_.swap(rhs.ordered_);
00176         xtms_.swap(rhs.xtms_);
00177         xalias_.swap(rhs.xalias_);
00178         xnames_.swap(rhs.xnames_);
00179         clause_.swap(rhs.clause_);
00180     }
00181 
00182     // forward declaration
00183     class variable;
00184     friend class variable;
00185 
00186 protected:
00188     mathTerms atms_;
00190     std::vector<AGREGADO> aggr_;
00192     std::vector<std::string> names_;
00194     StringToInt ordered_;
00196     mathTerms xtms_;
00198     StringToInt xalias_;
00200     std::vector<std::string> xnames_;
00201 
00202     std::string clause_;        
00203 
00204     ibis::selectLexer *lexer;   
00205 
00206     friend class ibis::selectParser;
00207 
00208     void fillNames();
00209     ibis::math::variable*
00210         addAgregado(ibis::selectClause::AGREGADO, ibis::math::term*);
00211     uint64_t decodeAName(const char*) const;
00212     void addTerm(ibis::math::term*, const std::string*);
00213     ibis::math::term* addRecursive(ibis::math::term*&);
00214     bool hasAggregation(const ibis::math::term *tm) const;
00215 
00216     typedef std::map<const char*, ibis::selectClause::variable*,
00217                      ibis::lessi> varMap;
00218     void gatherVariables(varMap &vmap, ibis::math::term* t) const;
00219 }; // class ibis::selectClause
00220 
00223 class ibis::selectClause::variable : public ibis::math::variable {
00224 public:
00225     variable(const char* s, const ibis::selectClause *c)
00226         : ibis::math::variable(s), sc_(c) {};
00227     variable(const variable &v) : ibis::math::variable(v), sc_(v.sc_) {};
00228     virtual variable* dup() const {return new variable(*this);}
00229     virtual void print(std::ostream&) const;
00230     void updateReference(const ibis::selectClause *c) {sc_=c;}
00231 
00232 private:
00233     const ibis::selectClause *sc_;
00234 
00235     variable();
00236 }; // class ibis::selectClause::variable
00237 
00242 inline uint32_t ibis::selectClause::numGroupbyKeys() const {
00243     uint32_t ret = (atms_.size() > aggr_.size() ?
00244                     atms_.size() - aggr_.size() : 0);
00245     for (uint32_t j = 0; j < aggr_.size(); ++j)
00246         ret += (aggr_[j] == NIL_AGGR);
00247     return ret;
00248 } // ibis::selectClause::numGroupbyKeys
00249 
00250 namespace std {
00251     inline ostream& operator<<(ostream& out, const ibis::selectClause& sel) {
00252         sel.print(out);
00253         return out;
00254     } // std::operator<<
00255 }
00256 #endif

Make It A Bit Faster
Contact us
Disclaimers
FastBit source code
FastBit mailing list archive