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-2012 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 printDetails(std::ostream&) const;
00109     void print(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     enum AGREGADO {NIL_AGGR, AVG, CNT, MAX, MIN, SUM, DISTINCT,
00139                    VARPOP, VARSAMP, STDPOP, STDSAMP, MEDIAN};
00141     uint32_t aggSize() const {return atms_.size();}
00143     AGREGADO getAggregator(uint32_t i) const {return aggr_[i];}
00144 
00147     const ibis::math::term* aggExpr(unsigned i) const {return atms_[i];}
00150     const char* aggName(unsigned i) const {return names_[i].c_str();}
00151     std::string aggDescription(unsigned i) const {
00152         return aggDescription(aggr_[i], atms_[i]);}
00153     std::string aggDescription(AGREGADO, const ibis::math::term*) const;
00154 
00155     bool isSeparable() const;
00156     const char* isUnivariate() const;
00157 
00158     typedef std::map<std::string, unsigned> StringToInt;
00159     const StringToInt& getOrdered() const {return ordered_;}
00161 
00162     int verify(const ibis::part&) const;
00163     int verifySome(const std::vector<uint32_t>&, const ibis::part&) const;
00164     static int verifyTerm(const ibis::math::term&, const ibis::part&,
00165                           const ibis::selectClause* =0);
00166 
00167     void getNullMask(const ibis::part&, ibis::bitvector&) const;
00168     void clear();
00169 
00171     selectClause& operator=(const selectClause& rhs) {
00172         selectClause tmp(rhs);
00173         swap(tmp);
00174         return *this;
00175     }
00177     void swap(selectClause& rhs) {
00178         atms_.swap(rhs.atms_);
00179         aggr_.swap(rhs.aggr_);
00180         names_.swap(rhs.names_);
00181         ordered_.swap(rhs.ordered_);
00182         xtms_.swap(rhs.xtms_);
00183         xalias_.swap(rhs.xalias_);
00184         xnames_.swap(rhs.xnames_);
00185         clause_.swap(rhs.clause_);
00186     }
00187 
00188     // forward declaration
00189     class variable;
00190     friend class variable;
00191 
00192 protected:
00194     mathTerms atms_;
00196     std::vector<AGREGADO> aggr_;
00198     std::vector<std::string> names_;
00200     StringToInt ordered_;
00202     mathTerms xtms_;
00204     StringToInt xalias_;
00206     std::vector<std::string> xnames_;
00207 
00208     std::string clause_;        
00209 
00210     ibis::selectLexer *lexer;   
00211 
00212     friend class ibis::selectParser;
00213 
00214     void fillNames();
00215     ibis::math::variable*
00216         addAgregado(ibis::selectClause::AGREGADO, ibis::math::term*);
00217     uint64_t decodeAName(const char*) const;
00218     void addTerm(ibis::math::term*, const std::string*);
00219     ibis::math::term* addRecursive(ibis::math::term*&);
00220     bool hasAggregation(const ibis::math::term *tm) const;
00221 
00222     typedef std::map<const char*, ibis::selectClause::variable*,
00223                      ibis::lessi> varMap;
00224     void gatherVariables(varMap &vmap, ibis::math::term* t) const;
00225 }; // class ibis::selectClause
00226 
00229 class ibis::selectClause::variable : public ibis::math::variable {
00230 public:
00231     variable(const char* s, const ibis::selectClause *c)
00232         : ibis::math::variable(s), sc_(c) {};
00233     variable(const variable &v) : ibis::math::variable(v), sc_(v.sc_) {};
00234     virtual variable* dup() const {return new variable(*this);}
00235     virtual void print(std::ostream&) const;
00236     void updateReference(const ibis::selectClause *c) {sc_=c;}
00237 
00238 private:
00239     const ibis::selectClause *sc_;
00240 
00241     variable();
00242 }; // class ibis::selectClause::variable
00243 
00244 namespace std {
00245     inline ostream& operator<<(ostream& out, const ibis::selectClause& sel) {
00246         sel.print(out);
00247         return out;
00248     } // std::operator<<
00249 }
00250 #endif

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