irelic.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_IRELIC_H
00006 #define IBIS_IRELIC_H
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 #if defined(_WIN32) && defined(_MSC_VER)
00015 #pragma warning(disable:4786)   // some identifier longer than 256 characters
00016 #endif
00017 #include "index.h"
00018 
00021 class ibis::relic : public ibis::index {
00022 public:
00023     virtual ~relic() {clear();};
00024     relic(const ibis::column* c, const char* f = 0);
00025     relic(const ibis::column* c, uint32_t popu, uint32_t ntpl=0);
00026     relic(const ibis::column* c, uint32_t card, array_t<uint32_t>& ints);
00027     relic(const ibis::column* c, ibis::fileManager::storage* st,
00028           size_t start = 8);
00029 
00030     virtual void print(std::ostream& out) const;
00031     virtual int  write(const char* dt) const;
00032     virtual int  read(const char* idxfile);
00033     virtual int  read(ibis::fileManager::storage* st);
00034     virtual long append(const char* dt, const char* df, uint32_t nnew);
00035 
00036     virtual long select(const ibis::qContinuousRange&, void*) const;
00037     virtual long select(const ibis::qContinuousRange&, void*,
00038                         ibis::bitvector&) const;
00039 
00040     using ibis::index::estimate;
00041     using ibis::index::estimateCost;
00042     virtual long evaluate(const ibis::qContinuousRange& expr,
00043                           ibis::bitvector& hits) const;
00044     virtual long evaluate(const ibis::qDiscreteRange& expr,
00045                           ibis::bitvector& hits) const;
00046 
00047     virtual void estimate(const ibis::qContinuousRange& expr,
00048                           ibis::bitvector& lower,
00049                           ibis::bitvector& upper) const {
00050         (void) evaluate(expr, lower);
00051         upper.clear();
00052     }
00053     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
00056     virtual float undecidable(const ibis::qContinuousRange&,
00057                               ibis::bitvector& iffy) const {
00058         iffy.clear();
00059         return 0.0;
00060     }
00061     virtual void estimate(const ibis::qDiscreteRange& expr,
00062                           ibis::bitvector& lower,
00063                           ibis::bitvector& upper) const {
00064         evaluate(expr, lower);
00065         upper.clear();
00066     }
00067     virtual uint32_t estimate(const ibis::qDiscreteRange&) const;
00068     virtual float undecidable(const ibis::qDiscreteRange&,
00069                               ibis::bitvector& iffy) const {
00070         iffy.clear();
00071         return 0.0;
00072     }
00073 
00074     virtual double estimateCost(const ibis::qContinuousRange& expr) const;
00075     virtual double estimateCost(const ibis::qDiscreteRange& expr) const;
00076 
00079     virtual void estimate(const ibis::relic& idx2,
00080                           const ibis::deprecatedJoin& expr,
00081                           const ibis::bitvector& mask,
00082                           ibis::bitvector64& lower,
00083                           ibis::bitvector64& upper) const;
00084     virtual void estimate(const ibis::relic& idx2,
00085                           const ibis::deprecatedJoin& expr,
00086                           const ibis::bitvector& mask,
00087                           const ibis::qRange* const range1,
00088                           const ibis::qRange* const range2,
00089                           ibis::bitvector64& lower,
00090                           ibis::bitvector64& upper) const;
00093     virtual int64_t estimate(const ibis::relic& idx2,
00094                              const ibis::deprecatedJoin& expr,
00095                              const ibis::bitvector& mask) const;
00096     virtual int64_t estimate(const ibis::relic& idx2,
00097                              const ibis::deprecatedJoin& expr,
00098                              const ibis::bitvector& mask,
00099                              const ibis::qRange* const range1,
00100                              const ibis::qRange* const range2) const;
00101 
00102     virtual INDEX_TYPE type() const {return RELIC;}
00103     virtual const char* name() const {return "basic";}
00104     // bin boundaries and counts of each bin
00105     virtual void binBoundaries(std::vector<double>& b) const;
00106     virtual void binWeights(std::vector<uint32_t>& b) const;
00107 
00108     virtual long getCumulativeDistribution(std::vector<double>& bds,
00109                                            std::vector<uint32_t>& cts) const;
00110     virtual long getDistribution(std::vector<double>& bds,
00111                                  std::vector<uint32_t>& cts) const;
00112     virtual double getMin() const {return (vals.empty()?DBL_MAX:vals[0]);}
00113     virtual double getMax() const {return (vals.empty()?-DBL_MAX:vals.back());}
00114     virtual double getSum() const;
00115 
00116     virtual void speedTest(std::ostream& out) const;
00117     long append(const ibis::relic& tail);
00118     long append(const array_t<uint32_t>& ind);
00119     array_t<uint32_t>* keys(const ibis::bitvector& mask) const;
00120 
00122     template <typename T>
00123     struct valpos {
00125         T val;
00127         bitvector::indexSet ind;
00131         bitvector::word_t j;
00132 
00134         valpos<T>() : val(0), j(0) {}
00136         valpos<T>(const T v, const bitvector& b)
00137         : val(v), ind(b.firstIndexSet()), j(0) {
00138             if (ind.nIndices() > 0 && ind.isRange())
00139                 j = *(ind.indices());
00140         }
00141 
00143         bitvector::word_t position() const {
00144             if (ind.isRange())
00145                 return j;
00146             else
00147                 return ind.indices()[j];
00148         }
00149 
00151         void next() {
00152             ++ j;
00153             if (ind.isRange()) {
00154                 if (j >= ind.indices()[1]) {
00155                     ++ ind;
00156                     if (ind.nIndices() > 0 && ind.isRange())
00157                         j = ind.indices()[0];
00158                     else
00159                         j = 0;
00160                 }
00161             }
00162             else if (j >= ind.nIndices()) {
00163                 ++ ind;
00164                 if (ind.nIndices() > 0 && ind.isRange())
00165                     j = ind.indices()[0];
00166                 else
00167                     j = 0;
00168             }
00169         }
00170     }; // valpos
00171 
00173     template<typename T>
00174     struct comparevalpos {
00175         bool operator()(const valpos<T>* x, const valpos<T>* y) {
00176             return (x->position() > y->position());
00177         }
00178     }; // comparevalpos
00179 
00180 protected:
00181     // protected member variables
00182     array_t<double> vals;
00183 
00184     int write32(int fdes) const;
00185     int write64(int fdes) const;
00186     // protected member functions
00187     uint32_t locate(const double& val) const;
00188     void     locate(const ibis::qContinuousRange& expr,
00189                     uint32_t& hit0, uint32_t& hit1) const;
00190 
00191     // a dummy constructor
00192     relic() : ibis::index() {}
00193     // free current resources, re-initialized all member variables
00194     virtual void clear();
00195     virtual double computeSum() const;
00196     virtual size_t getSerialSize() const throw();
00197 
00200     template <typename E>
00201     void construct(const array_t<E>& arr);
00203     void construct(const char* f = 0);
00204 
00205     long mergeValues(uint32_t, uint32_t, void*) const;
00206     template <typename T> static long
00207     mergeValuesT(const array_t<T>& vs,
00208                  const array_t<const bitvector*>& ps,
00209                  array_t<T>& res);
00210 
00211     template <typename T> struct mappedValues;
00212 
00213 private:
00214     // private member functions
00215     int64_t equiJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00216                      ibis::bitvector64& hits) const;
00217     int64_t deprecatedJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00218                       const double& delta, ibis::bitvector64& hits) const;
00219     int64_t compJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00220                      const ibis::math::term& delta,
00221                      ibis::bitvector64& hits) const;
00222 
00223     int64_t equiJoin(const ibis::relic& idx2,
00224                      const ibis::bitvector& mask) const;
00225     int64_t deprecatedJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00226                       const double& delta) const;
00227     int64_t compJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00228                      const ibis::math::term& delta) const;
00229 
00230     int64_t equiJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00231                      const ibis::qRange* const range1,
00232                      const ibis::qRange* const range2,
00233                      ibis::bitvector64& hits) const;
00234     int64_t deprecatedJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00235                       const ibis::qRange* const range1,
00236                       const ibis::qRange* const range2,
00237                       const double& delta, ibis::bitvector64& hits) const;
00240     int64_t compJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00241                      const ibis::qRange* const range1,
00242                      const ibis::qRange* const range2,
00243                      const ibis::math::term& delta,
00244                      ibis::bitvector64& hits) const {
00245         return compJoin(idx2, mask, delta, hits);
00246     }
00247 
00248     int64_t equiJoin(const ibis::relic& idx2,
00249                      const ibis::bitvector& mask,
00250                      const ibis::qRange* const range1,
00251                      const ibis::qRange* const range2) const;
00252     int64_t deprecatedJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00253                       const ibis::qRange* const range1,
00254                       const ibis::qRange* const range2,
00255                       const double& delta) const;
00258     int64_t compJoin(const ibis::relic& idx2, const ibis::bitvector& mask,
00259                      const ibis::qRange* const range1,
00260                      const ibis::qRange* const range2,
00261                      const ibis::math::term& delta) const {
00262         return compJoin(idx2, mask, delta);
00263     }
00264 
00265     relic(const relic&);
00266     relic& operator=(const relic&);
00267 }; // ibis::relic
00268 
00270 class ibis::slice : public ibis::relic {
00271 public:
00272     virtual ~slice() {clear();};
00273     slice(const ibis::column* c = 0, const char* f = 0);
00274     slice(const ibis::column* c, ibis::fileManager::storage* st,
00275           size_t start = 8);
00276 
00277     virtual int write(const char* dt) const;
00278     virtual void print(std::ostream& out) const;
00279     virtual int read(const char* idxfile);
00280     virtual int read(ibis::fileManager::storage* st);
00281 
00282     virtual long append(const char* dt, const char* df, uint32_t nnew);
00283 
00284     virtual long select(const ibis::qContinuousRange&, void*) const {
00285         return -1;}
00286     virtual long select(const ibis::qContinuousRange&, void*,
00287                         ibis::bitvector&) const {
00288         return -1;}
00289 
00290     using ibis::relic::estimate;
00291     using ibis::relic::estimateCost;
00292     virtual long evaluate(const ibis::qContinuousRange& expr,
00293                           ibis::bitvector& hits) const;
00294     virtual long evaluate(const ibis::qDiscreteRange& expr,
00295                           ibis::bitvector& hits) const;
00296 
00297     virtual void estimate(const ibis::qContinuousRange& expr,
00298                           ibis::bitvector& lower,
00299                           ibis::bitvector& upper) const;
00300     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
00301     virtual INDEX_TYPE type() const {return SLICE;}
00302     virtual const char* name() const {return "bit-sliced";}
00303     // number of records in each bin
00304     virtual void binWeights(std::vector<uint32_t>& b) const;
00305     virtual double getSum() const;
00306 
00307     virtual void speedTest(std::ostream& out) const;
00308     virtual double estimateCost(const ibis::qContinuousRange&) const {
00309         double ret;
00310         if (offset64.size() > bits.size())
00311             ret = offset64.back();
00312         else if (offset32.size() > bits.size())
00313             ret = offset32.back();
00314         else
00315             ret = 0.0;
00316         return ret;
00317     }
00318     virtual double estimateCost(const ibis::qDiscreteRange& expr) const {
00319         double ret;
00320         if (offset64.size() > bits.size())
00321             ret = offset64.back();
00322         else if (offset32.size() > bits.size())
00323             ret = offset32.back();
00324         else
00325             ret = 0.0;
00326         return ret;
00327     }
00328 
00329 protected:
00330     virtual void clear();
00331     virtual size_t getSerialSize() const throw();
00332 
00333 private:
00334     // private member variables
00335     array_t<uint32_t> cnts; // the counts for each distinct value
00336 
00337     // private member functions
00338     void construct1(const char* f = 0); // uses more temporary storage
00339     void construct2(const char* f = 0); // passes through data twice
00340     void setBit(const uint32_t i, const double val);
00341 
00342     int write32(int fdes) const;
00343     int write64(int fdes) const;
00344     void evalGE(ibis::bitvector& res, uint32_t b) const;
00345     void evalEQ(ibis::bitvector& res, uint32_t b) const;
00346 
00347     slice(const slice&);
00348     slice& operator=(const slice&);
00349 }; // ibis::slice
00350 
00353 class ibis::fade : public ibis::relic {
00354 public:
00355     virtual ~fade() {clear();};
00356     fade(const ibis::column* c = 0, const char* f = 0,
00357          const uint32_t nbase = 2);
00358     fade(const ibis::column* c, ibis::fileManager::storage* st,
00359          size_t start = 8);
00360 
00361     virtual int write(const char* dt) const;
00362     virtual void print(std::ostream& out) const;
00363     virtual int read(const char* idxfile);
00364     virtual int read(ibis::fileManager::storage* st);
00365 
00366     virtual long append(const char* dt, const char* df, uint32_t nnew);
00367 
00368     virtual long select(const ibis::qContinuousRange&, void*) const {
00369         return -1;}
00370     virtual long select(const ibis::qContinuousRange&, void*,
00371                         ibis::bitvector&) const {
00372         return -1;}
00373 
00374     using ibis::relic::estimate;
00375     using ibis::relic::estimateCost;
00376     virtual long evaluate(const ibis::qContinuousRange& expr,
00377                           ibis::bitvector& hits) const;
00378     virtual long evaluate(const ibis::qDiscreteRange& expr,
00379                           ibis::bitvector& hits) const;
00380 
00381     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
00382     virtual INDEX_TYPE type() const {return FADE;}
00383     virtual const char* name() const {return "multi-level range";}
00384 
00385     virtual void speedTest(std::ostream& out) const;
00386     // number of records in each bin
00387     virtual void binWeights(std::vector<uint32_t>& b) const;
00388     virtual double getSum() const;
00389     virtual double estimateCost(const ibis::qContinuousRange& expr) const;
00390     //virtual double estimateCost(const ibis::qDiscreteRange& expr) const;
00391 
00392 protected:
00393     // protected member variables
00394     array_t<uint32_t> cnts; // the counts for each distinct value
00395     array_t<uint32_t> bases;// the values of the bases used
00396 
00397     // protected member functions to be used by derived classes
00398     int write32(int fdes) const;
00399     int write64(int fdes) const;
00400     virtual void clear();
00401     virtual size_t getSerialSize() const throw();
00402 
00403 private:
00404     // private member functions
00405     void setBit(const uint32_t i, const double val);
00406     void construct1(const char* f = 0, const uint32_t nbase = 2);
00407     void construct2(const char* f = 0, const uint32_t nbase = 2);
00408 
00409     void evalEQ(ibis::bitvector& res, uint32_t b) const;
00410     void evalLE(ibis::bitvector& res, uint32_t b) const;
00411     void evalLL(ibis::bitvector& res, uint32_t b0, uint32_t b1) const;
00412 
00413     fade(const fade&);
00414     fade& operator=(const fade&);
00415 }; // ibis::fade
00416 
00419 class ibis::sbiad : public ibis::fade {
00420 public:
00421     virtual ~sbiad() {clear();};
00422     sbiad(const ibis::column* c = 0, const char* f = 0,
00423           const uint32_t nbase = 2);
00424     sbiad(const ibis::column* c, ibis::fileManager::storage* st,
00425           size_t start = 8);
00426 
00427     virtual int write(const char* dt) const;
00428     virtual void print(std::ostream& out) const;
00429     virtual long append(const char* dt, const char* df, uint32_t nnew);
00430 
00431     virtual long evaluate(const ibis::qContinuousRange& expr,
00432                           ibis::bitvector& hits) const;
00433     virtual long evaluate(const ibis::qDiscreteRange& expr,
00434                           ibis::bitvector& hits) const;
00435 
00436     virtual INDEX_TYPE type() const {return SBIAD;}
00437     virtual const char* name() const {return "multi-level interval";}
00438 
00439     virtual void speedTest(std::ostream& out) const;
00440     //virtual double estimateCost(const ibis::qContinuousRange& expr) const;
00441     //virtual double estimateCost(const ibis::qDiscreteRange& expr) const;
00442 
00443 private:
00444     // private member functions
00445     void setBit(const uint32_t i, const double val);
00446     void construct1(const char* f = 0, const uint32_t nbase = 2);
00447     void construct2(const char* f = 0, const uint32_t nbase = 2);
00448 
00449     void evalEQ(ibis::bitvector& res, uint32_t b) const;
00450     void evalLE(ibis::bitvector& res, uint32_t b) const;
00451     void evalLL(ibis::bitvector& res, uint32_t b0, uint32_t b1) const;
00452 
00453     sbiad(const sbiad&);
00454     sbiad& operator=(const sbiad&);
00455 }; // ibis::sbiad
00456 
00458 class ibis::sapid : public ibis::fade {
00459 public:
00460     virtual ~sapid() {clear();};
00461     sapid(const ibis::column* c = 0, const char* f = 0,
00462           const uint32_t nbase = 2);
00463     sapid(const ibis::column* c, ibis::fileManager::storage* st,
00464           size_t start = 8);
00465 
00466     virtual int write(const char* dt) const;
00467     virtual void print(std::ostream& out) const;
00468     virtual long append(const char* dt, const char* df, uint32_t nnew);
00469 
00470     virtual long evaluate(const ibis::qContinuousRange& expr,
00471                           ibis::bitvector& hits) const;
00472     virtual long evaluate(const ibis::qDiscreteRange& expr,
00473                           ibis::bitvector& hits) const;
00474 
00475     virtual INDEX_TYPE type() const {return SAPID;}
00476     virtual const char* name() const {return "multi-level equality";}
00477 
00478     virtual void speedTest(std::ostream& out) const;
00479     //virtual double estimateCost(const ibis::qContinuousRange& expr) const;
00480     //virtual double estimateCost(const ibis::qDiscreteRange& expr) const;
00481 
00482 private:
00483     // private member functions
00484     void setBit(const uint32_t i, const double val);
00485     void construct1(const char* f = 0, const uint32_t nbase = 2);
00486     void construct2(const char* f = 0, const uint32_t nbase = 2);
00487 
00488     void addBits_(uint32_t ib, uint32_t ie, ibis::bitvector& res) const;
00489     void evalEQ(ibis::bitvector& res, uint32_t b) const;
00490     void evalLE(ibis::bitvector& res, uint32_t b) const;
00491     void evalLL(ibis::bitvector& res, uint32_t b0, uint32_t b1) const;
00492 
00493     sapid(const sapid&);
00494     sapid& operator=(const sapid&);
00495 }; // ibis::sapid
00496 
00501 class ibis::fuzz : public ibis::relic {
00502 public:
00503     virtual ~fuzz() {clear();};
00504     fuzz(const ibis::column* c = 0, const char* f = 0);
00505     fuzz(const ibis::column* c, ibis::fileManager::storage* st,
00506          size_t start = 8);
00507 
00508     virtual int write(const char* dt) const;
00509     virtual void print(std::ostream& out) const;
00510     virtual int read(const char* idxfile);
00511     virtual int read(ibis::fileManager::storage* st);
00512 
00513     virtual long append(const char* dt, const char* df, uint32_t nnew);
00514 
00515     using ibis::relic::evaluate;
00516     using ibis::relic::estimate;
00517     using ibis::relic::estimateCost;
00518     virtual long evaluate(const ibis::qContinuousRange& expr,
00519                           ibis::bitvector& hits) const;
00520     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
00521     virtual double estimateCost(const ibis::qContinuousRange& expr) const;
00522 
00523     virtual INDEX_TYPE type() const {return FUZZ;}
00524     virtual const char* name() const {return "interval-equality";}
00525 
00526 protected:
00527     virtual void clear();
00528     virtual size_t getSerialSize() const throw();
00529 
00530 private:
00534     mutable array_t<bitvector*> cbits;
00535     array_t<uint32_t> cbounds;
00536     mutable array_t<int32_t> coffset32;
00537     mutable array_t<int64_t> coffset64;
00538 
00539     void coarsen(); // given fine level, add coarse level
00540     void activateCoarse() const; // activate all coarse level bitmaps
00541     void activateCoarse(uint32_t i) const; // activate one bitmap
00542     void activateCoarse(uint32_t i, uint32_t j) const;
00543 
00544     int writeCoarse32(int fdes) const;
00545     int writeCoarse64(int fdes) const;
00546     int readCoarse(const char *fn);
00547     void clearCoarse();
00548 
00550     long coarseEstimate(uint32_t lo, uint32_t hi) const;
00552     long coarseEvaluate(uint32_t lo, uint32_t hi, ibis::bitvector& res) const;
00553 
00554     fuzz(const fuzz&);
00555     fuzz& operator=(const fuzz&);
00556 }; // ibis::fuzz
00557 
00562 class ibis::bylt : public ibis::relic {
00563 public:
00564     virtual ~bylt() {clear();};
00565     bylt(const ibis::column* c = 0, const char* f = 0);
00566     bylt(const ibis::column* c, ibis::fileManager::storage* st,
00567          size_t start = 8);
00568 
00569     virtual int write(const char* dt) const;
00570     virtual void print(std::ostream& out) const;
00571     virtual int read(const char* idxfile);
00572     virtual int read(ibis::fileManager::storage* st);
00573 
00574     virtual long append(const char* dt, const char* df, uint32_t nnew);
00575 
00576     using ibis::relic::evaluate;
00577     using ibis::relic::estimate;
00578     using ibis::relic::estimateCost;
00579     virtual long evaluate(const ibis::qContinuousRange& expr,
00580                           ibis::bitvector& hits) const;
00581     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
00582     virtual double estimateCost(const ibis::qContinuousRange& expr) const;
00583 
00584     virtual INDEX_TYPE type() const {return BYLT;}
00585     virtual const char* name() const {return "range-equality";}
00586 
00587 protected:
00588     virtual void clear();
00589     virtual size_t getSerialSize() const throw();
00590 
00591 private:
00592     // the fine level is stored in ibis::relic, the parent class, only the
00593     // coarse bins are stored here.  The coarse bins use integer bin
00594     // boundaries; these integers are indices to the array vals and bits.
00595     mutable array_t<bitvector*> cbits;
00596     array_t<uint32_t> cbounds;
00597     mutable array_t<int32_t> coffset32;
00598     mutable array_t<int64_t> coffset64;
00599 
00600     void coarsen(); // given fine level, add coarse level
00601     void activateCoarse() const; // activate all coarse level bitmaps
00602     void activateCoarse(uint32_t i) const; // activate one bitmap
00603     void activateCoarse(uint32_t i, uint32_t j) const;
00604 
00605     int writeCoarse32(int fdes) const;
00606     int writeCoarse64(int fdes) const;
00607     int readCoarse(const char *fn);
00608 
00609     bylt(const bylt&);
00610     bylt& operator=(const bylt&);
00611 }; // ibis::bylt
00612 
00617 class ibis::zona : public ibis::relic {
00618 public:
00619     virtual ~zona() {clear();};
00620     zona(const ibis::column* c = 0, const char* f = 0);
00621     zona(const ibis::column* c, ibis::fileManager::storage* st,
00622          size_t start = 8);
00623 
00624     virtual int write(const char* dt) const;
00625     virtual void print(std::ostream& out) const;
00626     virtual int read(const char* idxfile);
00627     virtual int read(ibis::fileManager::storage* st);
00628 
00629     virtual long append(const char* dt, const char* df, uint32_t nnew);
00630 
00631     using ibis::relic::evaluate;
00632     using ibis::relic::estimate;
00633     using ibis::relic::estimateCost;
00634     virtual long evaluate(const ibis::qContinuousRange& expr,
00635                           ibis::bitvector& hits) const;
00636     virtual uint32_t estimate(const ibis::qContinuousRange& expr) const;
00637     virtual double estimateCost(const ibis::qContinuousRange& expr) const;
00638 
00639     virtual INDEX_TYPE type() const {return ZONA;}
00640     virtual const char* name() const {return "equality-equality";}
00641 
00642 protected:
00643     virtual void clear();
00644     virtual size_t getSerialSize() const throw();
00645 
00646 private:
00647     // the fine level is stored in ibis::relic, the parent class, only the
00648     // coarse bins are stored here.  The coarse bins use integer bin
00649     // boundaries; these integers are indices to the array vals and bits.
00650     mutable array_t<bitvector*> cbits;
00651     array_t<uint32_t> cbounds;
00652     mutable array_t<int32_t> coffset32;
00653     mutable array_t<int64_t> coffset64;
00654 
00655     void coarsen(); // given fine level, add coarse level
00656     void activateCoarse() const; // activate all coarse level bitmaps
00657     void activateCoarse(uint32_t i) const; // activate one bitmap
00658     void activateCoarse(uint32_t i, uint32_t j) const;
00659 
00660     int writeCoarse32(int fdes) const;
00661     int writeCoarse64(int fdes) const;
00662     int readCoarse(const char *fn);
00663 
00664     zona(const zona&);
00665     zona& operator=(const zona&);
00666 }; // ibis::zona
00667 
00670 template <typename T>
00671 struct ibis::relic::mappedValues {
00672 }; // ibis::relic::mappedValues
00673 #endif // IBIS_IRELIC_H

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