bundle.h
Go to the documentation of this file.
00001 //File: $Id$
00002 // Author: John Wu <John.Wu at ACM.org>
00003 //         Lawrence Berkeley National Laboratory
00004 // Copyright 2000-2012 the Regents of the University of California
00005 #ifndef IBIS_BUNDLE_H
00006 #define IBIS_BUNDLE_H
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 #include "query.h"      // ibis::query, ibis::selectClause
00019 #include "colValues.h"  // ibis::colValues
00020 
00021 namespace ibis {
00022     // class bundle defined in const.h,
00023     // the following are concrete classes used in the implementation
00024     class bundle0;
00025     class bundle1;
00026     //class bundle2s;
00027     //class bundle2t;
00028     class bundles;
00029     //class bundlet;
00030 }
00031 
00067 class FASTBIT_CXX_DLLSPEC ibis::bundle {
00068 public:
00069     static bundle* create(const ibis::query&, int =0);
00070     static bundle* create(const ibis::query&, const ibis::bitvector&, int =0);
00071     static bundle* create(const ibis::part&, const ibis::selectClause&, int =0);
00072 
00074     static const ibis::RIDSet* readRIDs(const char* dir, const uint32_t i);
00075 
00077     virtual uint32_t size() const {
00078         return (starts != 0 && starts->size()>0 ? starts->size()-1 : 0);}
00080     virtual uint32_t width() const {return 0;}
00082     virtual void print(std::ostream& out) const = 0;
00084     virtual void printAll(std::ostream& out) const = 0;
00086     virtual void printColumnNames(std::ostream& out) const = 0;
00093     virtual int32_t  getInt(uint32_t, uint32_t) const;
00094     virtual uint32_t getUInt(uint32_t, uint32_t) const;
00095     virtual int64_t  getLong(uint32_t, uint32_t) const;
00096     virtual uint64_t getULong(uint32_t, uint32_t) const;
00097     virtual float    getFloat(uint32_t, uint32_t) const;
00098     virtual double   getDouble(uint32_t, uint32_t) const;
00102     virtual std::string getString(uint32_t, uint32_t) const;
00104 
00107     virtual ibis::TYPE_T columnType(uint32_t) const {
00108         return ibis::UNKNOWN_TYPE;}
00111     virtual void* columnArray(uint32_t) const {return 0;}
00113     virtual const ibis::column* columnPointer(uint32_t) const {return 0;}
00114 
00116     virtual void reorder(const char *) = 0;
00118     virtual long truncate(uint32_t keep) = 0;
00120     virtual long truncate(uint32_t keep, uint32_t start) = 0;
00122     virtual long truncate(const char *names, uint32_t keep) = 0;
00123 
00124     virtual ~bundle();
00126     virtual void write(const ibis::query& q) const = 0;
00127 
00128     // some utility functions
00129     void sortRIDs(uint32_t i, uint32_t j);
00130     void swapRIDs(uint32_t i, uint32_t j) { // no error checking!
00131         if (rids) {
00132             ibis::rid_t tmp = (*rids)[i];
00133             (*rids)[i] = (*rids)[j];
00134             (*rids)[j] = tmp;
00135         }
00136     };
00138     uint32_t numRowsInBundle(uint32_t ind) const {
00139         if (starts != 0 && ind+1 < starts->size()) {
00140             return (*starts)[ind+1]-(*starts)[ind];
00141         }
00142         else {
00143             return 0U;
00144         }
00145     }
00148     uint32_t rowCounts(array_t<uint32_t>& cnt) const;
00149 
00151     const ibis::RIDSet* getRIDs(uint32_t ind) const {
00152         if (rids != 0 && starts != 0 && ind+1 < starts->size()) {
00153             return new ibis::RIDSet(*rids, (*starts)[ind], (*starts)[ind+1]);
00154         }
00155         else {
00156             return static_cast<ibis::RIDSet*>(0);
00157         }
00158     };
00160     const ibis::RIDSet* getRIDs() const {return rids;}
00162     const ibis::array_t<uint32_t>* getStarts() const {return starts;}
00163 
00164 protected:
00165     const ibis::selectClause& comps;
00166     array_t<uint32_t>* starts; // starting positions of bundles (in rids)
00167     ibis::RIDSet* rids;
00168     const char* id;
00169     mutable bool infile; // is the current content in file?
00170 
00171     // Hides constructors from others.
00172     bundle(const ibis::selectClause& c)
00173         : comps(c), starts(0), rids(0), id(""), infile(false) {};
00174     // use ibis::query::getRIDs(const ibis::bitvector&) const to avoid the
00175     // read lock required by ibis::query::getRIDs() const.
00176     explicit bundle(const ibis::query &q)
00177         : comps(q.components()), starts(0),
00178           rids(q.getRIDs(*(q.getHitVector()))), id(q.id()),
00179           infile(false) {
00180         if (rids != 0 && static_cast<long>(rids->size()) != q.getNumHits()) {
00181             delete rids;
00182             rids = 0;
00183         }
00184     };
00185     bundle(const ibis::query &q, const ibis::bitvector& hits)
00186         : comps(q.components()), starts(0), rids(q.getRIDs(hits)),
00187           id(q.id()), infile(false) {};
00188     bundle(const ibis::part &t, const ibis::selectClause &s)
00189         : comps(s), starts(new array_t<uint32_t>), rids(t.getRIDs()),
00190         id(t.name()), infile(false) {
00191         starts->resize(2);
00192         (*starts)[0] = 0;
00193         (*starts)[1] = t.nRows();
00194     }
00195 
00196 private:
00197     bundle(); // no default constructor
00198     bundle(const bundle&); // no copy constructor
00199     bundle& operator=(const bundle&); // no assignment operator
00200 }; // class ibis::bundle
00201 
00203 class FASTBIT_CXX_DLLSPEC ibis::bundle0 : public ibis::bundle {
00204 public:
00205     explicit bundle0(const ibis::query& q);
00206     bundle0(const ibis::query& q, const ibis::bitvector& hits);
00207     bundle0(const ibis::part& t, const ibis::selectClause &s);
00208 
00209     virtual void print(std::ostream& out) const;
00210     virtual void printAll(std::ostream& out) const;
00212     virtual void printColumnNames(std::ostream&) const {};
00213 
00214     // can not do anything
00215     virtual void reorder(const char *) {};
00216     // only one bundle.
00217     virtual long truncate(uint32_t) {return 1;}
00218     virtual long truncate(uint32_t, uint32_t) {return 1;}
00219     virtual long truncate(const char *, uint32_t) {return 1;}
00220 
00221     virtual void write(const ibis::query& q) const {
00222         if (rids != 0 && infile == false) {
00223             q.writeRIDs(rids);
00224             infile = true;
00225         }
00226     }
00227 }; // ibis::bundle0
00228 
00230 class FASTBIT_CXX_DLLSPEC ibis::bundle1 : public ibis::bundle {
00231 public:
00232     explicit bundle1(const ibis::query&, int =0);
00233     bundle1(const ibis::query&, const ibis::bitvector&, int =0);
00234     bundle1(const ibis::part&, const ibis::selectClause&, int =0);
00235     virtual ~bundle1();
00236 
00237     virtual uint32_t size() const {return (col ? col->size() : 0);}
00238     virtual uint32_t width() const {return 1;}
00239 
00240     virtual void write(const ibis::query&) const;
00241     virtual void print(std::ostream& out) const;
00242     virtual void printAll(std::ostream& out) const;
00243     virtual void printColumnNames(std::ostream& out) const;
00244 
00245     virtual int32_t     getInt(uint32_t, uint32_t) const;
00246     virtual uint32_t    getUInt(uint32_t, uint32_t) const;
00247     virtual int64_t     getLong(uint32_t, uint32_t) const;
00248     virtual uint64_t    getULong(uint32_t, uint32_t) const;
00249     virtual float       getFloat(uint32_t, uint32_t) const;
00250     virtual double      getDouble(uint32_t, uint32_t) const;
00251     virtual std::string getString(uint32_t, uint32_t) const;
00252 
00253     virtual const ibis::column* columnPointer(uint32_t j) const {
00254         return (j == 0 ? col->columnPointer() :
00255                 static_cast<const ibis::column*>(0));}
00256     virtual ibis::TYPE_T columnType(uint32_t j) const {
00257         return (j == 0 ? col->getType() : ibis::UNKNOWN_TYPE);}
00258     virtual void* columnArray(uint32_t j) const {
00259         return (j == 0 ? col->getArray() : 0);}
00260 
00266     virtual void reorder(const char *) {
00267         // if (direc.size() > 0 && direc[0] == false) {
00268         //     reverse();
00269         //     infile = false;
00270         // }
00271     }
00272     virtual long truncate(uint32_t);
00273     virtual long truncate(uint32_t, uint32_t);
00274     virtual long truncate(const char *, uint32_t keep);
00275 
00276 private:
00277     ibis::colValues* col;
00278     ibis::selectClause::AGREGADO aggr;
00279 
00281     void sort(int);
00283     void reverse();
00284 
00285     bundle1();
00286     bundle1(const bundle1&);
00287     bundle1& operator=(const bundle1&);
00288 }; // ibis::bundle1
00289 
00291 class FASTBIT_CXX_DLLSPEC ibis::bundles : public ibis::bundle {
00292 public:
00293     explicit bundles(const ibis::query&, int =0);
00294     bundles(const ibis::query&, const ibis::bitvector&, int =0);
00295     bundles(const ibis::part&, const ibis::selectClause&, int =0);
00296     virtual ~bundles() {clear();}
00297 
00298     virtual uint32_t size() const {
00299         return (cols.empty() ? 0 : cols.back()->size());}
00300     virtual uint32_t width() const {return cols.size();}
00301 
00302     virtual void print(std::ostream& out) const;
00303     virtual void printAll(std::ostream& out) const;
00304     virtual void printColumnNames(std::ostream& out) const;
00305     virtual void write(const ibis::query&) const;
00306 
00307     virtual int32_t     getInt(uint32_t, uint32_t) const;
00308     virtual uint32_t    getUInt(uint32_t, uint32_t) const;
00309     virtual int64_t     getLong(uint32_t, uint32_t) const;
00310     virtual uint64_t    getULong(uint32_t, uint32_t) const;
00311     virtual float       getFloat(uint32_t, uint32_t) const;
00312     virtual double      getDouble(uint32_t, uint32_t) const;
00313     virtual std::string getString(uint32_t, uint32_t) const;
00314 
00315     virtual const ibis::column* columnPointer(uint32_t j) const {
00316         return (j < cols.size() ? cols[j]->columnPointer() :
00317                 static_cast<const ibis::column*>(0));}
00318     virtual ibis::TYPE_T columnType(uint32_t j) const {
00319         return (j < cols.size() ? cols[j]->getType() : ibis::UNKNOWN_TYPE);}
00320     virtual void* columnArray(uint32_t j) const {
00321         return (j < cols.size() ? cols[j]->getArray() : 0);}
00322 
00323     virtual void reorder(const char *);
00324     virtual long truncate(uint32_t keep);
00325     virtual long truncate(uint32_t keep, uint32_t start);
00326     virtual long truncate(const char *names, uint32_t keep);
00327 
00328 private:
00329     colList cols;
00330     std::vector<ibis::selectClause::AGREGADO> aggr;
00331 
00332     void sort(int);
00333     void clear();
00334     void reverse();
00335 
00336     bundles();
00337     bundles(const bundles&);
00338     bundles& operator=(const bundles&);
00339 }; // ibis::bundles
00340 
00352 class FASTBIT_CXX_DLLSPEC ibis::query::result {
00353 public:
00354     result(ibis::query& q);
00355     ~result();
00356 
00357     uint32_t width() const {return(bdl_!=0 ? bdl_->width() : 0U);}
00358 
00360     bool next();
00362     bool nextBundle();
00365     void reset();
00366 
00370     int32_t getInt(const char *cname) const;
00372     uint32_t getUInt(const char *cname) const;
00374     int64_t getLong(const char *cname) const;
00376     uint64_t getULong(const char *cname) const;
00379     float getFloat(const char *cname) const;
00382     double getDouble(const char *cname) const;
00383     std::string getString(const char *cname) const;
00384 
00389     int32_t getInt(uint32_t selind) const {
00390         return bdl_->getInt(bid_-1, selind);
00391     }
00394     uint32_t getUInt(uint32_t selind) const {
00395         return bdl_->getUInt(bid_-1, selind);
00396     }
00398     int64_t getLong(uint32_t selind) const {
00399         return bdl_->getLong(bid_-1, selind);
00400     }
00403     uint64_t getULong(uint32_t selind) const {
00404         return bdl_->getULong(bid_-1, selind);
00405     }
00408     float getFloat(uint32_t selind) const {
00409         return bdl_->getFloat(bid_-1, selind);
00410     }
00413     double getDouble(uint32_t selind) const {
00414         return bdl_->getDouble(bid_-1, selind);
00415     }
00416 
00419     std::string getString(uint32_t selind) const {
00420         return bdl_->getString(bid_-1, selind);
00421     }
00422     inline uint32_t colPosition(const char *cname) const
00423     {return sel.find(cname);}
00424 
00425     void printColumnNames(std::ostream& out) const {
00426         if (bdl_ != 0) {
00427             bdl_->printColumnNames(out);
00428         }
00429     }
00430 
00431 private:
00432     ibis::query &que_;
00433     ibis::bundle *bdl_;
00434     const ibis::selectClause& sel;
00435     uint32_t bid_; // 0 for unused.
00436     uint32_t lib_; // results left in the bundle.
00437 
00438     result();
00439     result(const result&);
00440     result& operator=(const result&);
00441 }; // ibis::query::result
00442 #endif // IBIS_BUNDLE_H

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