colValues.h
Go to the documentation of this file.
00001 // File: $Id$
00002 // Author: John Wu <John.Wu at nersc.gov> Lawrence Berkeley National Laboratory
00003 // Copyright 2000-2011 the Regents of the University of California
00004 #ifndef IBIS_COLVALUES_H
00005 #define IBIS_COLVALUES_H
00006 #include "column.h"
00007 #include "utilidor.h"   // ibis::util::reorder
00008 
00011 
00014 class FASTBIT_CXX_DLLSPEC ibis::colValues {
00015 public:
00016     virtual ~colValues() {}
00017 
00019     static colValues* create(const ibis::column* c,
00020                              const ibis::bitvector& hits);
00022     static colValues* create(const ibis::column* c,
00023                              ibis::fileManager::storage* store,
00024                              const uint32_t start, const uint32_t end);
00026     static colValues* create(const ibis::column* c);
00027 
00029     virtual const ibis::column* operator->() const {return col;};
00030     virtual bool empty() const = 0;
00031     virtual void reduce(const array_t<uint32_t>& starts) = 0;
00032     virtual void reduce(const array_t<uint32_t>& starts,
00033                         ibis::selectClause::AGREGADO func) = 0;
00034     virtual void erase(uint32_t i, uint32_t j) = 0;
00035     virtual void swap(uint32_t i, uint32_t j) = 0;
00036     virtual uint32_t size() const = 0;
00037     virtual uint32_t elementSize() const = 0;
00039     virtual ibis::TYPE_T getType() const =0;
00041     virtual void* getArray() const =0;
00043     virtual void nosharing() =0;
00044 
00045     bool canSort() const
00046     {return (col ? col->type() != ibis::TEXT : false);}
00047 
00048     void swap(colValues& rhs) { // swap two colValues
00049         const ibis::column* c = rhs.col;
00050         rhs.col = col;
00051         col = c;
00052     }
00053 
00055     virtual uint32_t write(FILE* fptr) const  = 0;
00057     virtual void write(std::ostream& out, uint32_t i) const = 0;
00058 
00060     virtual void sort(uint32_t i, uint32_t j, bundle* bdl) = 0;
00063     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00064                       colList::iterator head, colList::iterator tail) = 0;
00067     virtual void sort(uint32_t i, uint32_t j,
00068                       array_t<uint32_t>& neworder) const = 0;
00071     virtual void reorder(const array_t<uint32_t>& ind) = 0;
00074     virtual array_t<uint32_t>*
00075     segment(const array_t<uint32_t>* old=0) const = 0;
00077     virtual long truncate(uint32_t keep) = 0;
00079     virtual long truncate(uint32_t keep, uint32_t start) = 0;
00081     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const = 0;
00083     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const = 0;
00084 
00085     virtual double getMin() const = 0;
00086     virtual double getMax() const = 0;
00087     virtual double getSum() const = 0;
00088     virtual int32_t getInt(uint32_t) const = 0;
00089     virtual uint32_t getUInt(uint32_t) const = 0;
00090     virtual int64_t getLong(uint32_t) const = 0;
00091     virtual uint64_t getULong(uint32_t) const = 0;
00092     virtual float getFloat(uint32_t) const = 0;
00093     virtual double getDouble(uint32_t) const = 0;
00094 
00095 protected:
00096     const ibis::column* col; 
00097 
00098     colValues() : col(0) {}
00099     colValues(const ibis::column* c) : col(c) {};
00100 
00101 private:
00102     colValues& operator=(const colValues&);
00103 }; // ibis::colValues
00104 
00106 class FASTBIT_CXX_DLLSPEC ibis::colInts : public ibis::colValues {
00107 public:
00108     colInts() : colValues(), array(0) {};
00109     colInts(const ibis::column* c, const ibis::bitvector& hits)
00110         : colValues(c), array(c->selectInts(hits)) {}
00111     colInts(const ibis::column* c, ibis::fileManager::storage* store,
00112             const uint32_t start, const uint32_t nelm)
00113         : colValues(c), array(new array_t<int32_t>(store, start, nelm)) {}
00114     colInts(const ibis::column* c);
00115     virtual ~colInts() {delete array;}
00116 
00117     virtual bool   empty() const {return (col==0 || array==0);}
00118     virtual uint32_t size() const {return (array ? array->size() : 0);}
00119     virtual uint32_t elementSize() const {return sizeof(int);}
00120     virtual ibis::TYPE_T getType() const {return ibis::INT;}
00121     virtual void* getArray() const {return array;}
00122     virtual void nosharing() {array->nosharing();}
00123 
00124     virtual void   reduce(const array_t<uint32_t>& starts);
00125     virtual void   reduce(const array_t<uint32_t>& starts,
00126                           ibis::selectClause::AGREGADO func);
00127     virtual void   erase(uint32_t i, uint32_t j) {
00128         array->erase(array->begin()+i, array->begin()+j);}
00129     virtual void   swap(uint32_t i, uint32_t j) {
00130         int32_t tmp = (*array)[i];
00131         (*array)[i] = (*array)[j];
00132         (*array)[j] = tmp;}
00133 
00134     void swap(colInts& rhs) { // swap two colInts
00135         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00136         array_t<int32_t>* a = rhs.array; rhs.array = array; array = a;}
00137 
00138     // write out whole array as binary
00139     virtual uint32_t write(FILE* fptr) const {
00140         if (array) {
00141             uint32_t nelm = array->size();
00142             return nelm - fwrite(array->begin(), sizeof(int), nelm, fptr);
00143         }
00144         else {
00145             return 0;
00146         }
00147     }
00148     // write ith element as text
00149     virtual void write(std::ostream& out, uint32_t i) const
00150     {out << (*array)[i];}
00151 
00152     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00153     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00154                       colList::iterator head, colList::iterator tail);
00155     virtual void sort(uint32_t i, uint32_t j,
00156                       array_t<uint32_t>& neworder) const;
00157     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00158     virtual void reorder(const array_t<uint32_t>& ind)
00159     {ibis::util::reorder(*array, ind);}
00160     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00161     {array->topk(k, ind);}
00162     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00163     {array->bottomk(k, ind);}
00164     virtual long truncate(uint32_t keep);
00165     virtual long truncate(uint32_t keep, uint32_t start);
00166 
00167     virtual double getMin() const;
00168     virtual double getMax() const;
00169     virtual double getSum() const;
00170     virtual int32_t getInt(uint32_t i) const {return (*array)[i];}
00171     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00172     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00173     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00174     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00175     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00176 
00177 private:
00178     array_t<int32_t>* array;
00179 
00180     colInts(const colInts&);
00181     colInts& operator=(const colInts&);
00182 }; // ibis::colInts
00183 
00185 class FASTBIT_CXX_DLLSPEC ibis::colUInts : public ibis::colValues {
00186 public:
00187     colUInts() : colValues(), array(0) {};
00188     colUInts(const ibis::column* c, const ibis::bitvector& hits)
00189         : colValues(c), array(c->selectUInts(hits)) {}
00190     colUInts(const ibis::column* c, ibis::fileManager::storage* store,
00191             const uint32_t start, const uint32_t nelm)
00192         : colValues(c), array(new array_t<uint32_t>(store, start, nelm)) {}
00193     colUInts(const ibis::column* c);
00194     virtual ~colUInts() {delete array;}
00195 
00196     virtual bool   empty() const {return (col==0 || array==0);}
00197     virtual uint32_t size() const {return (array ? array->size() : 0);}
00198     virtual uint32_t elementSize() const {return sizeof(unsigned);}
00199     virtual ibis::TYPE_T getType() const {return ibis::UINT;}
00200     virtual void* getArray() const {return array;}
00201     virtual void nosharing() {array->nosharing();}
00202 
00203     virtual void   erase(uint32_t i, uint32_t j) {
00204         array->erase(array->begin()+i, array->begin()+j);}
00205     virtual void   swap(uint32_t i, uint32_t j) {
00206         uint32_t tmp = (*array)[i];
00207         (*array)[i] = (*array)[j];
00208         (*array)[j] = tmp;}
00209 
00210     virtual void   reduce(const array_t<uint32_t>& starts);
00211     virtual void   reduce(const array_t<uint32_t>& starts,
00212                           ibis::selectClause::AGREGADO func);
00213     void swap(colUInts& rhs) { // swap two colUInts
00214         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00215         array_t<uint32_t>* a = rhs.array; rhs.array = array; array = a;}
00216 
00218     virtual uint32_t write(FILE* fptr) const {
00219         if (array) {
00220             uint32_t nelm = array->size();
00221             return nelm - fwrite(array->begin(), sizeof(unsigned), nelm, fptr);
00222         }
00223         else {
00224             return 0;
00225         }
00226     }
00228     virtual void write(std::ostream& out, uint32_t i) const {
00229         if (col->type() == ibis::CATEGORY || col->type() == ibis::TEXT) {
00230             std::string str;
00231             col->getString((*array)[i], str);
00232             if (str.empty()) {
00233                 out << "<NULL>";
00234             }
00235             else {
00236                 out << '"' << str << '"';
00237             }
00238         }
00239         else {
00240             out << (*array)[i];
00241         }
00242     }
00243 
00244     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00245     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00246                       colList::iterator head, colList::iterator tail);
00247     virtual void sort(uint32_t i, uint32_t j,
00248                       array_t<uint32_t>& neworder) const;
00249     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00250     virtual void reorder(const array_t<uint32_t>& ind)
00251     {ibis::util::reorder(*array, ind);}
00252     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00253     {array->topk(k, ind);}
00254     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00255     {array->bottomk(k, ind);}
00256     virtual long truncate(uint32_t keep);
00257     virtual long truncate(uint32_t keep, uint32_t start);
00258 
00259     virtual double getMin() const;
00260     virtual double getMax() const;
00261     virtual double getSum() const;
00262     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00263     virtual uint32_t getUInt(uint32_t i) const {return (*array)[i];}
00264     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00265     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00266     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00267     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00268 
00269 private:
00270     array_t<uint32_t>* array;
00271 
00272     colUInts(const colUInts&);
00273     colUInts& operator=(const colUInts&);
00274 }; // ibis::colUInts
00275 
00277 class FASTBIT_CXX_DLLSPEC ibis::colLongs : public ibis::colValues {
00278 public:
00279     colLongs() : colValues(), array(0) {};
00280     colLongs(const ibis::column* c, const ibis::bitvector& hits)
00281         : colValues(c), array(c->selectLongs(hits)) {}
00282     colLongs(const ibis::column* c, ibis::fileManager::storage* store,
00283             const uint32_t start, const uint32_t nelm)
00284         : colValues(c), array(new array_t<int64_t>(store, start, nelm)) {}
00285     colLongs(const ibis::column* c);
00286     virtual ~colLongs() {delete array;}
00287 
00288     virtual bool   empty() const {return (col==0 || array==0);}
00289     virtual uint32_t size() const {return (array ? array->size() : 0);}
00290     virtual uint32_t elementSize() const {return sizeof(int64_t);}
00291     virtual ibis::TYPE_T getType() const {return ibis::LONG;}
00292     virtual void* getArray() const {return array;}
00293     virtual void nosharing() {array->nosharing();}
00294 
00295     virtual void   reduce(const array_t<uint32_t>& starts);
00296     virtual void   reduce(const array_t<uint32_t>& starts,
00297                           ibis::selectClause::AGREGADO func);
00298     virtual void   erase(uint32_t i, uint32_t j) {
00299         array->erase(array->begin()+i, array->begin()+j);}
00300     virtual void   swap(uint32_t i, uint32_t j) {
00301         int64_t tmp = (*array)[i];
00302         (*array)[i] = (*array)[j];
00303         (*array)[j] = tmp;}
00304 
00305     void swap(colLongs& rhs) { // swap two colLongs
00306         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00307         array_t<int64_t>* a = rhs.array; rhs.array = array; array = a;}
00308 
00309     // write out whole array as binary
00310     virtual uint32_t write(FILE* fptr) const {
00311         if (array) {
00312             uint32_t nelm = array->size();
00313             return nelm - fwrite(array->begin(), sizeof(int64_t), nelm, fptr);
00314         }
00315         else {
00316             return 0;
00317         }
00318     }
00319     // write ith element as text
00320     virtual void write(std::ostream& out, uint32_t i) const
00321     {out << (*array)[i];}
00322 
00323     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00324     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00325                       colList::iterator head, colList::iterator tail);
00326     virtual void sort(uint32_t i, uint32_t j,
00327                       array_t<uint32_t>& neworder) const;
00328     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00329     virtual void reorder(const array_t<uint32_t>& ind)
00330     {ibis::util::reorder(*array, ind);}
00331     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00332     {array->topk(k, ind);}
00333     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00334     {array->bottomk(k, ind);}
00335     virtual long truncate(uint32_t keep);
00336     virtual long truncate(uint32_t keep, uint32_t start);
00337 
00338     virtual double getMin() const;
00339     virtual double getMax() const;
00340     virtual double getSum() const;
00341     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00342     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00343     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00344     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00345     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00346     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00347 
00348 private:
00349     array_t<int64_t>* array;
00350 
00351     colLongs(const colLongs&);
00352     colLongs& operator=(const colLongs&);
00353 }; // ibis::colLongs
00354 
00356 class FASTBIT_CXX_DLLSPEC ibis::colULongs : public ibis::colValues {
00357 public:
00358     colULongs() : colValues(), array(0) {};
00359     colULongs(const ibis::column* c, const ibis::bitvector& hits)
00360         : colValues(c), array(c->selectULongs(hits)) {}
00361     colULongs(const ibis::column* c, ibis::fileManager::storage* store,
00362             const uint32_t start, const uint32_t nelm)
00363         : colValues(c), array(new array_t<uint64_t>(store, start, nelm)) {}
00364     colULongs(const ibis::column* c);
00365     virtual ~colULongs() {delete array;}
00366 
00367     virtual bool   empty() const {return (col==0 || array==0);}
00368     virtual uint32_t size() const {return (array ? array->size() : 0);}
00369     virtual uint32_t elementSize() const {return sizeof(uint64_t);}
00370     virtual ibis::TYPE_T getType() const {return ibis::ULONG;}
00371     virtual void* getArray() const {return array;}
00372     virtual void nosharing() {array->nosharing();}
00373 
00374     virtual void   erase(uint32_t i, uint32_t j) {
00375         array->erase(array->begin()+i, array->begin()+j);}
00376     virtual void   swap(uint32_t i, uint32_t j) {
00377         uint64_t tmp = (*array)[i];
00378         (*array)[i] = (*array)[j];
00379         (*array)[j] = tmp;}
00380 
00381     virtual void   reduce(const array_t<uint32_t>& starts);
00382     virtual void   reduce(const array_t<uint32_t>& starts,
00383                           ibis::selectClause::AGREGADO func);
00384     void swap(colULongs& rhs) { // swap two colULongs
00385         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00386         array_t<uint64_t>* a = rhs.array; rhs.array = array; array = a;}
00387 
00389     virtual uint32_t write(FILE* fptr) const {
00390         if (array) {
00391             uint32_t nelm = array->size();
00392             return nelm - fwrite(array->begin(), sizeof(uint64_t), nelm, fptr);
00393         }
00394         else {
00395             return 0;
00396         }
00397     }
00399     virtual void write(std::ostream& out, uint32_t i) const {
00400         if (col->type() == ibis::CATEGORY || col->type() == ibis::TEXT) {
00401             std::string str;
00402             col->getString((*array)[i], str);
00403             if (str.empty()) {
00404                 out << "<NULL>";
00405             }
00406             else {
00407                 out << str;
00408             }
00409         }
00410         else {
00411             out << (*array)[i];
00412         }
00413     }
00414 
00415     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00416     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00417                       colList::iterator head, colList::iterator tail);
00418     virtual void sort(uint32_t i, uint32_t j,
00419                       array_t<uint32_t>& neworder) const;
00420     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00421     virtual void reorder(const array_t<uint32_t>& ind)
00422     {ibis::util::reorder(*array, ind);}
00423     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00424     {array->topk(k, ind);}
00425     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00426     {array->bottomk(k, ind);}
00427     virtual long truncate(uint32_t keep);
00428     virtual long truncate(uint32_t keep, uint32_t start);
00429 
00430     virtual double getMin() const;
00431     virtual double getMax() const;
00432     virtual double getSum() const;
00433     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00434     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00435     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00436     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00437     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00438     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00439 
00440 private:
00441     array_t<uint64_t>* array;
00442 
00443     colULongs(const colULongs&);
00444     colULongs& operator=(const colULongs&);
00445 }; // ibis::colULongs
00446 
00448 class FASTBIT_CXX_DLLSPEC ibis::colShorts : public ibis::colValues {
00449 public:
00450     colShorts() : colValues(), array(0) {};
00451     colShorts(const ibis::column* c, const ibis::bitvector& hits)
00452         : colValues(c), array(c->selectShorts(hits)) {}
00453     colShorts(const ibis::column* c, ibis::fileManager::storage* store,
00454               const uint32_t start, const uint32_t nelm)
00455         : colValues(c), array(new array_t<int16_t>(store, start, nelm)) {}
00456     colShorts(const ibis::column* c);
00457     virtual ~colShorts() {delete array;}
00458 
00459     virtual bool   empty() const {return (col==0 || array==0);}
00460     virtual uint32_t size() const {return (array ? array->size() : 0);}
00461     virtual uint32_t elementSize() const {return sizeof(int16_t);}
00462     virtual ibis::TYPE_T getType() const {return ibis::SHORT;}
00463     virtual void* getArray() const {return array;}
00464     virtual void nosharing() {array->nosharing();}
00465 
00466     virtual void   reduce(const array_t<uint32_t>& starts);
00467     virtual void   reduce(const array_t<uint32_t>& starts,
00468                           ibis::selectClause::AGREGADO func);
00469     virtual void   erase(uint32_t i, uint32_t j) {
00470         array->erase(array->begin()+i, array->begin()+j);}
00471     virtual void   swap(uint32_t i, uint32_t j) {
00472         int16_t tmp = (*array)[i];
00473         (*array)[i] = (*array)[j];
00474         (*array)[j] = tmp;}
00475 
00476     void swap(colShorts& rhs) { // swap two colShorts
00477         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00478         array_t<int16_t>* a = rhs.array; rhs.array = array; array = a;}
00479 
00480     // write out whole array as binary
00481     virtual uint32_t write(FILE* fptr) const {
00482         if (array) {
00483             uint32_t nelm = array->size();
00484             return nelm - fwrite(array->begin(), sizeof(int16_t), nelm, fptr);
00485         }
00486         else {
00487             return 0;
00488         }
00489     }
00490     // write ith element as text
00491     virtual void write(std::ostream& out, uint32_t i) const
00492     {out << (*array)[i];}
00493 
00494     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00495     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00496                       colList::iterator head, colList::iterator tail);
00497     virtual void sort(uint32_t i, uint32_t j,
00498                       array_t<uint32_t>& neworder) const;
00499     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00500     virtual void reorder(const array_t<uint32_t>& ind)
00501     {ibis::util::reorder(*array, ind);}
00502     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00503     {array->topk(k, ind);}
00504     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00505     {array->bottomk(k, ind);}
00506     virtual long truncate(uint32_t keep);
00507     virtual long truncate(uint32_t keep, uint32_t start);
00508 
00509     virtual double getMin() const;
00510     virtual double getMax() const;
00511     virtual double getSum() const;
00512     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00513     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00514     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00515     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00516     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00517     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00518 
00519 private:
00520     array_t<int16_t>* array;
00521 
00522     colShorts(const colShorts&);
00523     colShorts& operator=(const colShorts&);
00524 }; // ibis::colShorts
00525 
00527 class FASTBIT_CXX_DLLSPEC ibis::colUShorts : public ibis::colValues {
00528 public:
00529     colUShorts() : colValues(), array(0) {};
00530     colUShorts(const ibis::column* c, const ibis::bitvector& hits)
00531         : colValues(c), array(c->selectUShorts(hits)) {}
00532     colUShorts(const ibis::column* c, ibis::fileManager::storage* store,
00533             const uint32_t start, const uint32_t nelm)
00534         : colValues(c), array(new array_t<uint16_t>(store, start, nelm)) {}
00535     colUShorts(const ibis::column* c);
00536     virtual ~colUShorts() {delete array;}
00537 
00538     virtual bool   empty() const {return (col==0 || array==0);}
00539     virtual uint32_t size() const {return (array ? array->size() : 0);}
00540     virtual uint32_t elementSize() const {return sizeof(uint16_t);}
00541     virtual ibis::TYPE_T getType() const {return ibis::USHORT;}
00542     virtual void* getArray() const {return array;}
00543     virtual void nosharing() {array->nosharing();}
00544 
00545     virtual void   erase(uint32_t i, uint32_t j) {
00546         array->erase(array->begin()+i, array->begin()+j);}
00547     virtual void   swap(uint32_t i, uint32_t j) {
00548         uint16_t tmp = (*array)[i];
00549         (*array)[i] = (*array)[j];
00550         (*array)[j] = tmp;}
00551 
00552     virtual void   reduce(const array_t<uint32_t>& starts);
00553     virtual void   reduce(const array_t<uint32_t>& starts,
00554                           ibis::selectClause::AGREGADO func);
00555     void swap(colUShorts& rhs) { // swap two colUShorts
00556         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00557         array_t<uint16_t>* a = rhs.array; rhs.array = array; array = a;}
00558 
00560     virtual uint32_t write(FILE* fptr) const {
00561         if (array) {
00562             uint32_t nelm = array->size();
00563             return nelm - fwrite(array->begin(), sizeof(uint16_t), nelm, fptr);
00564         }
00565         else {
00566             return 0;
00567         }
00568     }
00570     virtual void write(std::ostream& out, uint32_t i) const {
00571         out << (*array)[i];
00572     }
00573 
00574     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00575     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00576                       colList::iterator head, colList::iterator tail);
00577     virtual void sort(uint32_t i, uint32_t j,
00578                       array_t<uint32_t>& neworder) const;
00579     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00580     virtual void reorder(const array_t<uint32_t>& ind)
00581     {ibis::util::reorder(*array, ind);}
00582     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00583     {array->topk(k, ind);}
00584     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00585     {array->bottomk(k, ind);}
00586     virtual long truncate(uint32_t keep);
00587     virtual long truncate(uint32_t keep, uint32_t start);
00588 
00589     virtual double getMin() const;
00590     virtual double getMax() const;
00591     virtual double getSum() const;
00592     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00593     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00594     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00595     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00596     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00597     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00598 
00599 private:
00600     array_t<uint16_t>* array;
00601 
00602     colUShorts(const colUShorts&);
00603     colUShorts& operator=(const colUShorts&);
00604 }; // ibis::colUShorts
00605 
00607 class FASTBIT_CXX_DLLSPEC ibis::colBytes : public ibis::colValues {
00608 public:
00609     colBytes() : colValues(), array(0) {};
00610     colBytes(const ibis::column* c, const ibis::bitvector& hits)
00611         : colValues(c), array(c->selectBytes(hits)) {}
00612     colBytes(const ibis::column* c, ibis::fileManager::storage* store,
00613             const uint32_t start, const uint32_t nelm)
00614         : colValues(c), array(new array_t<signed char>(store, start, nelm)) {}
00615     colBytes(const ibis::column* c);
00616     virtual ~colBytes() {delete array;}
00617 
00618     virtual bool   empty() const {return (col==0 || array==0);}
00619     virtual uint32_t size() const {return (array ? array->size() : 0);}
00620     virtual uint32_t elementSize() const {return sizeof(char);}
00621     virtual ibis::TYPE_T getType() const {return ibis::BYTE;}
00622     virtual void* getArray() const {return array;}
00623     virtual void nosharing() {array->nosharing();}
00624 
00625     virtual void   reduce(const array_t<uint32_t>& starts);
00626     virtual void   reduce(const array_t<uint32_t>& starts,
00627                           ibis::selectClause::AGREGADO func);
00628     virtual void   erase(uint32_t i, uint32_t j) {
00629         array->erase(array->begin()+i, array->begin()+j);}
00630     virtual void   swap(uint32_t i, uint32_t j) {
00631         signed char tmp = (*array)[i];
00632         (*array)[i] = (*array)[j];
00633         (*array)[j] = tmp;}
00634 
00635     void swap(colBytes& rhs) { // swap two colBytes
00636         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00637         array_t<signed char>* a = rhs.array; rhs.array = array; array = a;}
00638 
00639     // write out whole array as binary
00640     virtual uint32_t write(FILE* fptr) const {
00641         if (array) {
00642             uint32_t nelm = array->size();
00643             return nelm - fwrite(array->begin(), sizeof(char), nelm, fptr);
00644         }
00645         else {
00646             return 0;
00647         }
00648     }
00649     // write ith element as text
00650     virtual void write(std::ostream& out, uint32_t i) const
00651     {out << (int16_t)(*array)[i];}
00652 
00653     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00654     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00655                       colList::iterator head, colList::iterator tail);
00656     virtual void sort(uint32_t i, uint32_t j,
00657                       array_t<uint32_t>& neworder) const;
00658     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00659     virtual void reorder(const array_t<uint32_t>& ind)
00660     {ibis::util::reorder(*array, ind);}
00661     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00662     {array->topk(k, ind);}
00663     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00664     {array->bottomk(k, ind);}
00665     virtual long truncate(uint32_t keep);
00666     virtual long truncate(uint32_t keep, uint32_t start);
00667 
00668     virtual double getMin() const;
00669     virtual double getMax() const;
00670     virtual double getSum() const;
00671     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00672     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00673     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00674     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00675     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00676     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00677 
00678 private:
00679     array_t<signed char>* array;
00680 
00681     colBytes(const colBytes&);
00682     colBytes& operator=(const colBytes&);
00683 }; // ibis::colBytes
00684 
00686 class FASTBIT_CXX_DLLSPEC ibis::colUBytes : public ibis::colValues {
00687 public:
00688     colUBytes() : colValues(), array(0) {};
00689     colUBytes(const ibis::column* c, const ibis::bitvector& hits)
00690         : colValues(c), array(c->selectUBytes(hits)) {}
00691     colUBytes(const ibis::column* c, ibis::fileManager::storage* store,
00692             const uint32_t start, const uint32_t nelm)
00693         : colValues(c), array(new array_t<unsigned char>(store, start, nelm)) {}
00694     colUBytes(const ibis::column* c);
00695     virtual ~colUBytes() {delete array;}
00696 
00697     virtual bool   empty() const {return (col==0 || array==0);}
00698     virtual uint32_t size() const {return (array ? array->size() : 0);}
00699     virtual uint32_t elementSize() const {return sizeof(char);}
00700     virtual ibis::TYPE_T getType() const {return ibis::UBYTE;}
00701     virtual void* getArray() const {return array;}
00702     virtual void nosharing() {array->nosharing();}
00703 
00704     virtual void   erase(uint32_t i, uint32_t j) {
00705         array->erase(array->begin()+i, array->begin()+j);}
00706     virtual void   swap(uint32_t i, uint32_t j) {
00707         unsigned char tmp = (*array)[i];
00708         (*array)[i] = (*array)[j];
00709         (*array)[j] = tmp;}
00710 
00711     virtual void   reduce(const array_t<uint32_t>& starts);
00712     virtual void   reduce(const array_t<uint32_t>& starts,
00713                           ibis::selectClause::AGREGADO func);
00714     void swap(colUBytes& rhs) { // swap two colUBytes
00715         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00716         array_t<unsigned char>* a = rhs.array; rhs.array = array; array = a;}
00717 
00719     virtual uint32_t write(FILE* fptr) const {
00720         if (array) {
00721             uint32_t nelm = array->size();
00722             return nelm - fwrite(array->begin(), sizeof(char), nelm, fptr);
00723         }
00724         else {
00725             return 0;
00726         }
00727     }
00729     virtual void write(std::ostream& out, uint32_t i) const {
00730         out << (uint16_t)(*array)[i];
00731     }
00732 
00733     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00734     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00735                       colList::iterator head, colList::iterator tail);
00736     virtual void sort(uint32_t i, uint32_t j,
00737                       array_t<uint32_t>& neworder) const;
00738     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00739     virtual void reorder(const array_t<uint32_t>& ind)
00740     {ibis::util::reorder(*array, ind);}
00741     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00742     {array->topk(k, ind);}
00743     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00744     {array->bottomk(k, ind);}
00745     virtual long truncate(uint32_t keep);
00746     virtual long truncate(uint32_t keep, uint32_t start);
00747 
00748     virtual double getMin() const;
00749     virtual double getMax() const;
00750     virtual double getSum() const;
00751     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00752     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00753     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00754     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00755     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00756     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00757 
00758 private:
00759     array_t<unsigned char>* array;
00760 
00761     colUBytes(const colUBytes&);
00762     colUBytes& operator=(const colUBytes&);
00763 }; // ibis::colUBytes
00764 
00766 class FASTBIT_CXX_DLLSPEC ibis::colFloats : public ibis::colValues {
00767 public:
00768     colFloats() : colValues(), array(0) {};
00769     colFloats(const ibis::column* c, const ibis::bitvector& hits)
00770         : colValues(c), array(c->selectFloats(hits)) {}
00771     colFloats(const ibis::column* c, ibis::fileManager::storage* store,
00772               const uint32_t start, const uint32_t nelm)
00773         : colValues(c), array(new array_t<float>(store, start, nelm)) {}
00774     colFloats(const ibis::column* c);
00775     virtual ~colFloats() {delete array;}
00776 
00777     virtual bool   empty() const {return (col==0 || array==0);}
00778     virtual uint32_t size() const {return (array ? array->size() : 0);}
00779     virtual uint32_t elementSize() const {return sizeof(float);}
00780     virtual ibis::TYPE_T getType() const {return ibis::FLOAT;}
00781     virtual void* getArray() const {return array;}
00782     virtual void nosharing() {array->nosharing();}
00783 
00784     virtual void   erase(uint32_t i, uint32_t j) {
00785         array->erase(array->begin()+i, array->begin()+j);}
00786     virtual void   swap(uint32_t i, uint32_t j) {
00787         float tmp = (*array)[i];
00788         (*array)[i] = (*array)[j];
00789         (*array)[j] = tmp;}
00790 
00791     void swap(colFloats& rhs) { // swap two colFloats
00792         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00793         array_t<float>* a = rhs.array; rhs.array = array; array = a;}
00794     virtual void   reduce(const array_t<uint32_t>& starts);
00795     virtual void   reduce(const array_t<uint32_t>& starts,
00796                           ibis::selectClause::AGREGADO func);
00797 
00798     // write out whole array as binary
00799     virtual uint32_t write(FILE* fptr) const {
00800         if (array) {
00801             uint32_t nelm = array->size();
00802             return nelm - fwrite(array->begin(), sizeof(float), nelm, fptr);
00803         }
00804         else {
00805             return 0;
00806         }
00807     }
00808     // write ith element as text
00809     virtual void write(std::ostream& out, uint32_t i) const {
00810         out << (*array)[i];}
00811 
00812     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00813     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00814                       colList::iterator head, colList::iterator tail);
00815     virtual void sort(uint32_t i, uint32_t j,
00816                       array_t<uint32_t>& neworder) const;
00817     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00818     virtual void reorder(const array_t<uint32_t>& ind)
00819     {ibis::util::reorder(*array, ind);}
00820     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00821     {array->topk(k, ind);}
00822     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00823     {array->bottomk(k, ind);}
00824     virtual long truncate(uint32_t keep);
00825     virtual long truncate(uint32_t keep, uint32_t start);
00826 
00827     virtual double getMin() const;
00828     virtual double getMax() const;
00829     virtual double getSum() const;
00830     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00831     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00832     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00833     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00834     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00835     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00836 
00837 private:
00838     array_t<float>* array;
00839 
00840     colFloats(const colFloats&);
00841     colFloats& operator=(const colFloats&);
00842 }; // ibis::colFloats
00843 
00845 class FASTBIT_CXX_DLLSPEC ibis::colDoubles : public ibis::colValues {
00846 public:
00847     colDoubles() : colValues(), array(0) {};
00848     colDoubles(const ibis::column* c, const ibis::bitvector& hits)
00849         : colValues(c), array(c->selectDoubles(hits)) {}
00850     colDoubles(const ibis::column* c, ibis::fileManager::storage* store,
00851                const uint32_t start, const uint32_t end)
00852         : colValues(c), array(new array_t<double>(store, start, end)) {}
00853     colDoubles(const ibis::column* c);
00854     colDoubles(size_t n, double v) : array(new array_t<double>(n, v)) {}
00855     virtual ~colDoubles() {delete array;}
00856 
00857     virtual bool   empty() const {return (col==0 || array==0);}
00858     virtual uint32_t size() const {return (array ? array->size() : 0);}
00859     virtual uint32_t elementSize() const {return sizeof(double);}
00860     virtual ibis::TYPE_T getType() const {return ibis::DOUBLE;}
00861     virtual void* getArray() const {return array;}
00862     virtual void nosharing() {array->nosharing();}
00863 
00864     virtual void   erase(uint32_t i, uint32_t j) {
00865         array->erase(array->begin()+i, array->begin()+j);}
00866     virtual void   swap(uint32_t i, uint32_t j) {
00867         double tmp = (*array)[i];
00868         (*array)[i] = (*array)[j];
00869         (*array)[j] = tmp;}
00870 
00871     void swap(colDoubles& rhs) { // swap two colDoubles
00872         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00873         array_t<double>* a = rhs.array; rhs.array = array; array = a;}
00874     virtual void   reduce(const array_t<uint32_t>& starts);
00875     virtual void   reduce(const array_t<uint32_t>& starts,
00876                           ibis::selectClause::AGREGADO func);
00877 
00878     // write out whole array as binary
00879     virtual uint32_t write(FILE* fptr) const {
00880         if (array) {
00881             uint32_t nelm = array->size();
00882             return nelm - fwrite(array->begin(), sizeof(double), nelm, fptr);
00883         }
00884         else {
00885             return 0;
00886         }
00887     }
00888     // write ith element as text
00889     virtual void write(std::ostream& out, uint32_t i) const {
00890         out.precision(12); out << (*array)[i];}
00891 
00892     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00893     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00894                       colList::iterator head, colList::iterator tail);
00895     virtual void sort(uint32_t i, uint32_t j,
00896                       array_t<uint32_t>& neworder) const;
00897     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00898     virtual void reorder(const array_t<uint32_t>& ind)
00899     {ibis::util::reorder(*array, ind);}
00900     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00901     {array->topk(k, ind);}
00902     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00903     {array->bottomk(k, ind);}
00904     virtual long truncate(uint32_t keep);
00905     virtual long truncate(uint32_t keep, uint32_t start);
00906 
00907     virtual double getMin() const;
00908     virtual double getMax() const;
00909     virtual double getSum() const;
00910     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00911     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00912     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00913     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00914     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00915     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00916 
00917 private:
00918     array_t<double>* array;
00919 
00920     colDoubles(const colDoubles&);
00921     colDoubles& operator=(const colDoubles&);
00922 }; // ibis::colDoubles
00923 
00925 class FASTBIT_CXX_DLLSPEC ibis::colStrings : public ibis::colValues {
00926 public:
00927     colStrings() : colValues(), array(0) {};
00928     colStrings(const ibis::column* c, const ibis::bitvector& hits)
00929         : colValues(c), array(c->selectStrings(hits)) {}
00930     colStrings(const ibis::column* c);
00931     colStrings(size_t n, const std::string& v)
00932         : array(new std::vector<std::string>(n, v)) {}
00933     virtual ~colStrings() {delete array;}
00934 
00935     virtual bool         empty() const {return (col==0 || array==0);}
00936     virtual uint32_t     size() const {return (array ? array->size() : 0);}
00937     virtual uint32_t     elementSize() const {return 0;}
00938     virtual ibis::TYPE_T getType() const {return col->type();}
00939     virtual void*        getArray() const {return array;}
00940     virtual void         nosharing() {/* neve shared */}
00941 
00942     virtual void erase(uint32_t i, uint32_t j) {
00943         array->erase(array->begin()+i, array->begin()+j);}
00944     virtual void swap(uint32_t i, uint32_t j) {(*array)[i].swap((*array)[j]);}
00945 
00946     void swap(colStrings& rhs) { // swap two colStrings
00947         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00948         std::vector<std::string>* a = rhs.array; rhs.array = array; array = a;}
00949     virtual void   reduce(const array_t<uint32_t>& starts);
00950     virtual void   reduce(const array_t<uint32_t>& starts,
00951                           ibis::selectClause::AGREGADO func);
00952 
00953     // write out whole array as binary
00954     virtual uint32_t write(FILE* fptr) const;
00955     // write ith element as text
00956     virtual void write(std::ostream& out, uint32_t i) const {
00957         out << '"' << (*array)[i] << '"';}
00958 
00959     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00960     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00961                       colList::iterator head, colList::iterator tail);
00962     virtual void sort(uint32_t i, uint32_t j,
00963                       array_t<uint32_t>& neworder) const;
00964     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00965     virtual void reorder(const array_t<uint32_t>& ind);
00966     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const;
00967     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const;
00968     virtual long truncate(uint32_t keep);
00969     virtual long truncate(uint32_t keep, uint32_t start);
00970 
00972     virtual double getMin() const {return FASTBIT_DOUBLE_NULL;}
00974     virtual double getMax() const {return FASTBIT_DOUBLE_NULL;}
00976     virtual double getSum() const {return FASTBIT_DOUBLE_NULL;}
00978     virtual int32_t getInt(uint32_t) const {return 0;}
00980     virtual uint32_t getUInt(uint32_t) const {return 0;}
00982     virtual int64_t getLong(uint32_t) const {return 0;}
00984     virtual uint64_t getULong(uint32_t) const {return 0;}
00986     virtual float getFloat(uint32_t) const {return  FASTBIT_FLOAT_NULL;}
00988     virtual double getDouble(uint32_t) const {return FASTBIT_DOUBLE_NULL;}
00989 
00990 private:
00992     std::vector<std::string>* array;
00993 
00994     colStrings(const colStrings&);
00995     colStrings& operator=(const colStrings&);
00996 
00997     void sortsub(uint32_t i, uint32_t j, array_t<uint32_t>& ind) const;
00998     uint32_t partitionsub(uint32_t, uint32_t, array_t<uint32_t>&) const;
00999 }; // ibis::colStrings
01000 #endif

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