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-2011 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& q);
00070     static bundle* create(const ibis::query& q, const ibis::bitvector& hits);
00071     static bundle* create(const ibis::part& p, const ibis::selectClause& sel);
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) : 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;
00091     virtual int32_t  getInt(uint32_t, uint32_t) const;
00092     virtual uint32_t getUInt(uint32_t, uint32_t) const;
00093     virtual int64_t  getLong(uint32_t, uint32_t) const;
00094     virtual uint64_t getULong(uint32_t, uint32_t) const;
00095     virtual float    getFloat(uint32_t, uint32_t) const;
00096     virtual double   getDouble(uint32_t, uint32_t) const;
00100     virtual std::string getString(uint32_t, uint32_t) const;
00102 
00105     virtual ibis::TYPE_T columnType(uint32_t) const {
00106         return ibis::UNKNOWN_TYPE;}
00109     virtual void* columnArray(uint32_t) const {return 0;}
00110 
00112     virtual void reorder(const char *, int) = 0;
00114     virtual long truncate(uint32_t keep) = 0;
00116     virtual long truncate(uint32_t keep, uint32_t start) = 0;
00118     virtual long truncate(const char *names, int direction, uint32_t keep) = 0;
00119 
00120     virtual ~bundle();
00122     virtual void write(const ibis::query& q) const = 0;
00123 
00124     // some utility functions
00125     void sortRIDs(uint32_t i, uint32_t j);
00126     void swapRIDs(uint32_t i, uint32_t j) { // no error checking!
00127         if (rids) {
00128             ibis::rid_t tmp = (*rids)[i];
00129             (*rids)[i] = (*rids)[j];
00130             (*rids)[j] = tmp;
00131         }
00132     };
00134     uint32_t numRowsInBundle(uint32_t ind) const {
00135         if (starts != 0 && ind+1 < starts->size()) {
00136             return (*starts)[ind+1]-(*starts)[ind];
00137         }
00138         else {
00139             return 0U;
00140         }
00141     }
00144     uint32_t rowCounts(array_t<uint32_t>& cnt) const;
00145 
00147     const ibis::RIDSet* getRIDs(uint32_t ind) const {
00148         if (rids != 0 && starts != 0 && ind+1 < starts->size()) {
00149             return new ibis::RIDSet(*rids, (*starts)[ind], (*starts)[ind+1]);
00150         }
00151         else {
00152             return static_cast<ibis::RIDSet*>(0);
00153         }
00154     };
00156     const ibis::RIDSet* getRIDs() const {return rids;}
00158     const ibis::array_t<uint32_t>* getStarts() const {return starts;}
00159 
00160 protected:
00161     const ibis::selectClause& comps;
00162     array_t<uint32_t>* starts; // starting positions of bundles (in rids)
00163     ibis::RIDSet* rids;
00164     const char* id;
00165     mutable bool infile; // is the current content in file?
00166 
00167     // Hides constructors from others.
00168     bundle(const ibis::selectClause& c)
00169         : comps(c), starts(0), rids(0), id(""), infile(false) {};
00170     // use ibis::query::getRIDs(const ibis::bitvector&) const to avoid the
00171     // read lock required by ibis::query::getRIDs() const.
00172     explicit bundle(const ibis::query& q)
00173         : comps(q.components()), starts(0),
00174           rids(q.getRIDs(*(q.getHitVector()))), id(q.id()),
00175           infile(false) {
00176         if (rids != 0 && static_cast<long>(rids->size()) != q.getNumHits()) {
00177             delete rids;
00178             rids = 0;
00179         }
00180     };
00181     bundle(const ibis::query& q, const ibis::bitvector& hits)
00182         : comps(q.components()), starts(0), rids(q.getRIDs(hits)),
00183           id(q.id()), infile(false) {};
00184 
00185 private:
00186     bundle(); // no default constructor
00187     bundle(const bundle&); // no copy constructor
00188     bundle& operator=(const bundle&); // no assignment operator
00189 }; // class ibis::bundle
00190 
00192 class FASTBIT_CXX_DLLSPEC ibis::bundle0 : public ibis::bundle {
00193 public:
00194     explicit bundle0(const ibis::query& q) : bundle(q) {q.writeRIDs(rids);};
00195     bundle0(const ibis::query& q, const ibis::bitvector& hits)
00196         : bundle(q, hits) {
00197         if (rids != 0 && static_cast<long>(rids->size()) != q.getNumHits()) {
00198             delete rids;
00199             rids = 0;
00200         }
00201     };
00202 
00203     virtual uint32_t size() const {return (rids ? rids->size() : 0);}
00204     virtual void print(std::ostream& out) const;
00205     virtual void printAll(std::ostream& out) const;
00206 
00207     // can not do anything
00208     virtual void reorder(const char *, int) {};
00209     // only one bundle.
00210     virtual long truncate(uint32_t) {return 1;}
00211     virtual long truncate(uint32_t, uint32_t) {return 1;}
00212     virtual long truncate(const char *, int, uint32_t)
00213     {return 1;}
00214 
00215     virtual void write(const ibis::query& q) const {
00216         if (rids != 0 && infile == false) {
00217             q.writeRIDs(rids);
00218             infile = true;
00219         }
00220     }
00221 }; // ibis::bundle0
00222 
00224 class FASTBIT_CXX_DLLSPEC ibis::bundle1 : public ibis::bundle {
00225 public:
00226     explicit bundle1(const ibis::query& q);
00227     bundle1(const ibis::query& q, const ibis::bitvector& hits);
00228     bundle1(const ibis::part& tbl, const ibis::selectClause& sel);
00229     virtual ~bundle1();
00230     virtual void write(const ibis::query&) const;
00231 
00232     virtual uint32_t size() const {return (col ? col->size() : 0);}
00233     virtual uint32_t width() const {return 1;}
00234     // print the bundle values to the specified output stream
00235     virtual void print(std::ostream& out) const;
00236     // print the bundle values along with the RIDs
00237     virtual void printAll(std::ostream& out) const;
00238     virtual int32_t  getInt(uint32_t, uint32_t) const;
00239     virtual uint32_t getUInt(uint32_t, uint32_t) const;
00240     virtual int64_t  getLong(uint32_t, uint32_t) const;
00241     virtual uint64_t getULong(uint32_t, uint32_t) const;
00242     virtual float    getFloat(uint32_t, uint32_t) const;
00243     virtual double   getDouble(uint32_t, uint32_t) const;
00244     virtual std::string getString(uint32_t, uint32_t) const;
00245 
00246     virtual ibis::TYPE_T columnType(uint32_t j) const {
00247         return (j == 0 ? col->getType() : ibis::UNKNOWN_TYPE);}
00248     virtual void* columnArray(uint32_t j) const {
00249         return (j == 0 ? col->getArray() : 0);}
00250 
00256     virtual void reorder(const char *, int direction) {
00257         if (direction < 0) {
00258             reverse();
00259             infile = false;
00260         }
00261     }
00262     virtual long truncate(uint32_t);
00263     virtual long truncate(uint32_t, uint32_t);
00264     virtual long truncate(const char *, int direction, uint32_t keep) {
00265         if (direction < 0) {
00266             reverse();
00267             infile = false;
00268         }
00269         return truncate(keep);
00270     }
00271 
00272 private:
00273     ibis::colValues* col;
00274     ibis::selectClause::AGREGADO aggr;
00275 
00277     void sort();
00279     void reverse();
00280 
00281     bundle1();
00282     bundle1(const bundle1&);
00283     bundle1& operator=(const bundle1&);
00284 }; // ibis::bundle1
00285 
00287 class FASTBIT_CXX_DLLSPEC ibis::bundles : public ibis::bundle {
00288 public:
00289     explicit bundles(const ibis::query& q);
00290     bundles(const ibis::query& q, const ibis::bitvector& hits);
00291     bundles(const ibis::part& tbl, const ibis::selectClause& sel);
00292     virtual ~bundles() {clear();}
00293     virtual void write(const ibis::query&) const;
00294 
00295     virtual uint32_t size() const {
00296         return (cols.empty() ? 0 : cols.back()->size());}
00297     virtual uint32_t width() const {return cols.size();}
00298     // print the bundle values to the specified output stream
00299     virtual void print(std::ostream& out) const;
00300     // print the bundle values along with the RIDs
00301     virtual void printAll(std::ostream& out) const;
00302     virtual int32_t  getInt(uint32_t, uint32_t) const;
00303     virtual uint32_t getUInt(uint32_t, uint32_t) const;
00304     virtual int64_t  getLong(uint32_t, uint32_t) const;
00305     virtual uint64_t getULong(uint32_t, uint32_t) const;
00306     virtual float    getFloat(uint32_t, uint32_t) const;
00307     virtual double   getDouble(uint32_t, uint32_t) const;
00308     virtual std::string getString(uint32_t, uint32_t) const;
00309 
00310     virtual ibis::TYPE_T columnType(uint32_t j) const {
00311         return (j < cols.size() ? cols[j]->getType() : ibis::UNKNOWN_TYPE);}
00312     virtual void* columnArray(uint32_t j) const {
00313         return (j < cols.size() ? cols[j]->getArray() : 0);}
00314 
00315     virtual void reorder(const char *names, int direction);
00316     virtual long truncate(uint32_t keep);
00317     virtual long truncate(uint32_t keep, uint32_t start);
00318     virtual long truncate(const char *names, int direction, uint32_t keep);
00319 
00320 private:
00321     colList cols;
00322     std::vector<ibis::selectClause::AGREGADO> aggr;
00323 
00324     void sort();
00325     void clear();
00326     void reverse();
00327 
00328     bundles();
00329     bundles(const bundles&);
00330     bundles& operator=(const bundles&);
00331 }; // ibis::bundles
00332 
00344 class FASTBIT_CXX_DLLSPEC ibis::query::result {
00345 public:
00346     result(ibis::query& q);
00347     ~result();
00348 
00350     bool next();
00353     void reset();
00354 
00358     int32_t getInt(const char *cname) const;
00360     uint32_t getUInt(const char *cname) const;
00362     int64_t getLong(const char *cname) const;
00364     uint64_t getULong(const char *cname) const;
00367     float getFloat(const char *cname) const;
00370     double getDouble(const char *cname) const;
00371     std::string getString(const char *cname) const;
00372 
00377     int32_t getInt(uint32_t selind) const {
00378         return bdl_->getInt(bid_-1, selind);
00379     }
00382     uint32_t getUInt(uint32_t selind) const {
00383         return bdl_->getUInt(bid_-1, selind);
00384     }
00386     int64_t getLong(uint32_t selind) const {
00387         return bdl_->getLong(bid_-1, selind);
00388     }
00391     uint64_t getULong(uint32_t selind) const {
00392         return bdl_->getULong(bid_-1, selind);
00393     }
00396     float getFloat(uint32_t selind) const {
00397         return bdl_->getFloat(bid_-1, selind);
00398     }
00401     double getDouble(uint32_t selind) const {
00402         return bdl_->getDouble(bid_-1, selind);
00403     }
00406     std::string getString(uint32_t selind) const {
00407         return bdl_->getString(bid_-1, selind);
00408     }
00409     inline uint32_t colPosition(const char *cname) const
00410     {return sel.find(cname);}
00411 
00412 private:
00413     ibis::query &que_;
00414     ibis::bundle *bdl_;
00415     const ibis::selectClause& sel;
00416     uint32_t bid_; // 0 for unused.
00417     uint32_t lib_; // results left in the bundle.
00418 
00419     result();
00420     result(const result&);
00421     result& operator=(const result&);
00422 }; // ibis::query::result
00423 #endif // IBIS_BUNDLE_H

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