FastBit: colValues.h Source File (ibis1.1.5)

00001 // File: $Id$
00002 // Author: John Wu <John.Wu at nersc.gov> Lawrence Berkeley National Laboratory
00003 // Copyright 2000-2009 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 nelm);
00026     static colValues* create(const ibis::column* c, void* vals);
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 void topk(uint32_t k, array_t<uint32_t> &ind) const = 0;
00081     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const = 0;
00082 
00083     virtual double getMin() const = 0;
00084     virtual double getMax() const = 0;
00085     virtual double getSum() const = 0;
00086     virtual int32_t getInt(uint32_t) const = 0;
00087     virtual uint32_t getUInt(uint32_t) const = 0;
00088     virtual int64_t getLong(uint32_t) const = 0;
00089     virtual uint64_t getULong(uint32_t) const = 0;
00090     virtual float getFloat(uint32_t) const = 0;
00091     virtual double getDouble(uint32_t) const = 0;
00092 
00093 protected:
00094     const ibis::column* col; 
00095 
00096     colValues() : col(0) {}
00097     colValues(const ibis::column* c) : col(c) {};
00098 
00099 private:
00100     colValues& operator=(const colValues&);
00101 }; // ibis::colValues
00102 
00104 class FASTBIT_CXX_DLLSPEC ibis::colInts : public ibis::colValues {
00105 public:
00106     colInts() : colValues(), array(0) {};
00107     colInts(const ibis::column* c, const ibis::bitvector& hits)
00108         : colValues(c), array(c->selectInts(hits)) {}
00109     colInts(const ibis::column* c, ibis::fileManager::storage* store,
00110             const uint32_t start, const uint32_t nelm)
00111         : colValues(c), array(new array_t<int32_t>(store, start, nelm)) {}
00112     colInts(const ibis::column* c, void* vals);
00113     virtual ~colInts() {delete array;}
00114 
00115     virtual bool   empty() const {return (col==0 || array==0);}
00116     virtual uint32_t size() const {return (array ? array->size() : 0);}
00117     virtual uint32_t elementSize() const {return sizeof(int);}
00118     virtual ibis::TYPE_T getType() const {return ibis::INT;}
00119     virtual void* getArray() const {return array;}
00120     virtual void nosharing() {array->nosharing();}
00121 
00122     virtual void   reduce(const array_t<uint32_t>& starts);
00123     virtual void   reduce(const array_t<uint32_t>& starts,
00124                           ibis::selectClause::AGREGADO func);
00125     virtual void   erase(uint32_t i, uint32_t j) {
00126         array->erase(array->begin()+i, array->begin()+j);}
00127     virtual void   swap(uint32_t i, uint32_t j) {
00128         int tmp = (*array)[i]; (*array)[i] = (*array)[j]; (*array)[j] = tmp;}
00129 
00130     void swap(colInts& rhs) { // swap two colInts
00131         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00132         array_t<int32_t>* a = rhs.array; rhs.array = array; array = a;}
00133 
00134     // write out whole array as binary
00135     virtual uint32_t write(FILE* fptr) const {
00136         if (array) {
00137             uint32_t nelm = array->size();
00138             return nelm - fwrite(array->begin(), sizeof(int), nelm, fptr);
00139         }
00140         else {
00141             return 0;
00142         }
00143     }
00144     // write ith element as text
00145     virtual void write(std::ostream& out, uint32_t i) const
00146     {out << (*array)[i];}
00147 
00148     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00149     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00150                       colList::iterator head, colList::iterator tail);
00151     virtual void sort(uint32_t i, uint32_t j,
00152                       array_t<uint32_t>& neworder) const;
00153     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00154     virtual void reorder(const array_t<uint32_t>& ind)
00155     {ibis::util::reorder(*array, ind);}
00156     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00157     {array->topk(k, ind);}
00158     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00159     {array->bottomk(k, ind);}
00160     virtual long truncate(uint32_t keep) {
00161         if (array == 0) return 0;
00162         if (array->size() > keep) {
00163             array->nosharing();
00164             array->resize(keep);
00165         }
00166         return array->size();
00167     }
00168 
00169     virtual double getMin() const;
00170     virtual double getMax() const;
00171     virtual double getSum() const;
00172     virtual int32_t getInt(uint32_t i) const {return (*array)[i];}
00173     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00174     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00175     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00176     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00177     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00178 
00179 private:
00180     array_t<int32_t>* array;
00181 
00182     colInts(const colInts&);
00183     colInts& operator=(const colInts&);
00184 }; // ibis::colInts
00185 
00187 class FASTBIT_CXX_DLLSPEC ibis::colUInts : public ibis::colValues {
00188 public:
00189     colUInts() : colValues(), array(0) {};
00190     colUInts(const ibis::column* c, const ibis::bitvector& hits)
00191         : colValues(c), array(c->selectUInts(hits)) {}
00192     colUInts(const ibis::column* c, ibis::fileManager::storage* store,
00193             const uint32_t start, const uint32_t nelm)
00194         : colValues(c), array(new array_t<uint32_t>(store, start, nelm)) {}
00195     colUInts(const ibis::column* c, void* vals);
00196     virtual ~colUInts() {delete array;}
00197 
00198     virtual bool   empty() const {return (col==0 || array==0);}
00199     virtual uint32_t size() const {return (array ? array->size() : 0);}
00200     virtual uint32_t elementSize() const {return sizeof(unsigned);}
00201     virtual ibis::TYPE_T getType() const {return ibis::UINT;}
00202     virtual void* getArray() const {return array;}
00203     virtual void nosharing() {array->nosharing();}
00204 
00205     virtual void   erase(uint32_t i, uint32_t j) {
00206         array->erase(array->begin()+i, array->begin()+j);}
00207     virtual void   swap(uint32_t i, uint32_t j) {
00208         unsigned tmp = (*array)[i]; (*array)[i] = (*array)[j];
00209         (*array)[j] = tmp;}
00210 
00211     virtual void   reduce(const array_t<uint32_t>& starts);
00212     virtual void   reduce(const array_t<uint32_t>& starts,
00213                           ibis::selectClause::AGREGADO func);
00214     void swap(colUInts& rhs) { // swap two colUInts
00215         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00216         array_t<uint32_t>* a = rhs.array; rhs.array = array; array = a;}
00217 
00219     virtual uint32_t write(FILE* fptr) const {
00220         if (array) {
00221             uint32_t nelm = array->size();
00222             return nelm - fwrite(array->begin(), sizeof(unsigned), nelm, fptr);
00223         }
00224         else {
00225             return 0;
00226         }
00227     }
00229     virtual void write(std::ostream& out, uint32_t i) const {
00230         if (col->type() == ibis::CATEGORY || col->type() == ibis::TEXT) {
00231             std::string str;
00232             col->getString((*array)[i], str);
00233             if (str.empty()) {
00234                 out << "<NULL>";
00235             }
00236             else {
00237                 out << str;
00238             }
00239         }
00240         else {
00241             out << (*array)[i];
00242         }
00243     }
00244 
00245     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00246     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00247                       colList::iterator head, colList::iterator tail);
00248     virtual void sort(uint32_t i, uint32_t j,
00249                       array_t<uint32_t>& neworder) const;
00250     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00251     virtual void reorder(const array_t<uint32_t>& ind)
00252     {ibis::util::reorder(*array, ind);}
00253     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00254     {array->topk(k, ind);}
00255     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00256     {array->bottomk(k, ind);}
00257     virtual long truncate(uint32_t keep) {
00258         if (array == 0) return 0;
00259         if (array->size() > keep) {
00260             array->nosharing();
00261             array->resize(keep);
00262         }
00263         return array->size();
00264     }
00265 
00266     virtual double getMin() const;
00267     virtual double getMax() const;
00268     virtual double getSum() const;
00269     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00270     virtual uint32_t getUInt(uint32_t i) const {return (*array)[i];}
00271     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00272     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00273     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00274     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00275 
00276 private:
00277     array_t<uint32_t>* array;
00278 
00279     colUInts(const colUInts&);
00280     colUInts& operator=(const colUInts&);
00281 }; // ibis::colUInts
00282 
00284 class FASTBIT_CXX_DLLSPEC ibis::colLongs : public ibis::colValues {
00285 public:
00286     colLongs() : colValues(), array(0) {};
00287     colLongs(const ibis::column* c, const ibis::bitvector& hits)
00288         : colValues(c), array(c->selectLongs(hits)) {}
00289     colLongs(const ibis::column* c, ibis::fileManager::storage* store,
00290             const uint32_t start, const uint32_t nelm)
00291         : colValues(c), array(new array_t<int64_t>(store, start, nelm)) {}
00292     colLongs(const ibis::column* c, void* vals);
00293     virtual ~colLongs() {delete array;}
00294 
00295     virtual bool   empty() const {return (col==0 || array==0);}
00296     virtual uint32_t size() const {return (array ? array->size() : 0);}
00297     virtual uint32_t elementSize() const {return sizeof(int);}
00298     virtual ibis::TYPE_T getType() const {return ibis::LONG;}
00299     virtual void* getArray() const {return array;}
00300     virtual void nosharing() {array->nosharing();}
00301 
00302     virtual void   reduce(const array_t<uint32_t>& starts);
00303     virtual void   reduce(const array_t<uint32_t>& starts,
00304                           ibis::selectClause::AGREGADO func);
00305     virtual void   erase(uint32_t i, uint32_t j) {
00306         array->erase(array->begin()+i, array->begin()+j);}
00307     virtual void   swap(uint32_t i, uint32_t j) {
00308         int64_t tmp = (*array)[i];
00309         (*array)[i] = (*array)[j];
00310         (*array)[j] = tmp;}
00311 
00312     void swap(colLongs& rhs) { // swap two colLongs
00313         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00314         array_t<int64_t>* a = rhs.array; rhs.array = array; array = a;}
00315 
00316     // write out whole array as binary
00317     virtual uint32_t write(FILE* fptr) const {
00318         if (array) {
00319             uint32_t nelm = array->size();
00320             return nelm - fwrite(array->begin(), sizeof(int), nelm, fptr);
00321         }
00322         else {
00323             return 0;
00324         }
00325     }
00326     // write ith element as text
00327     virtual void write(std::ostream& out, uint32_t i) const
00328     {out << (*array)[i];}
00329 
00330     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00331     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00332                       colList::iterator head, colList::iterator tail);
00333     virtual void sort(uint32_t i, uint32_t j,
00334                       array_t<uint32_t>& neworder) const;
00335     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00336     virtual void reorder(const array_t<uint32_t>& ind)
00337     {ibis::util::reorder(*array, ind);}
00338     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00339     {array->topk(k, ind);}
00340     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00341     {array->bottomk(k, ind);}
00342     virtual long truncate(uint32_t keep) {
00343         if (array == 0) return 0;
00344         if (array->size() > keep) {
00345             array->nosharing();
00346             array->resize(keep);
00347         }
00348         return array->size();
00349     }
00350 
00351     virtual double getMin() const;
00352     virtual double getMax() const;
00353     virtual double getSum() const;
00354     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00355     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00356     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00357     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00358     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00359     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00360 
00361 private:
00362     array_t<int64_t>* array;
00363 
00364     colLongs(const colLongs&);
00365     colLongs& operator=(const colLongs&);
00366 }; // ibis::colLongs
00367 
00369 class FASTBIT_CXX_DLLSPEC ibis::colULongs : public ibis::colValues {
00370 public:
00371     colULongs() : colValues(), array(0) {};
00372     colULongs(const ibis::column* c, const ibis::bitvector& hits)
00373         : colValues(c), array(c->selectULongs(hits)) {}
00374     colULongs(const ibis::column* c, ibis::fileManager::storage* store,
00375             const uint32_t start, const uint32_t nelm)
00376         : colValues(c), array(new array_t<uint64_t>(store, start, nelm)) {}
00377     colULongs(const ibis::column* c, void* vals);
00378     virtual ~colULongs() {delete array;}
00379 
00380     virtual bool   empty() const {return (col==0 || array==0);}
00381     virtual uint32_t size() const {return (array ? array->size() : 0);}
00382     virtual uint32_t elementSize() const {return sizeof(unsigned);}
00383     virtual ibis::TYPE_T getType() const {return ibis::ULONG;}
00384     virtual void* getArray() const {return array;}
00385     virtual void nosharing() {array->nosharing();}
00386 
00387     virtual void   erase(uint32_t i, uint32_t j) {
00388         array->erase(array->begin()+i, array->begin()+j);}
00389     virtual void   swap(uint32_t i, uint32_t j) {
00390         uint64_t tmp = (*array)[i]; (*array)[i] = (*array)[j];
00391         (*array)[j] = tmp;}
00392 
00393     virtual void   reduce(const array_t<uint32_t>& starts);
00394     virtual void   reduce(const array_t<uint32_t>& starts,
00395                           ibis::selectClause::AGREGADO func);
00396     void swap(colULongs& rhs) { // swap two colULongs
00397         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00398         array_t<uint64_t>* a = rhs.array; rhs.array = array; array = a;}
00399 
00401     virtual uint32_t write(FILE* fptr) const {
00402         if (array) {
00403             uint32_t nelm = array->size();
00404             return nelm - fwrite(array->begin(), sizeof(unsigned), nelm, fptr);
00405         }
00406         else {
00407             return 0;
00408         }
00409     }
00411     virtual void write(std::ostream& out, uint32_t i) const {
00412         if (col->type() == ibis::CATEGORY || col->type() == ibis::TEXT) {
00413             std::string str;
00414             col->getString((*array)[i], str);
00415             if (str.empty()) {
00416                 out << "<NULL>";
00417             }
00418             else {
00419                 out << str;
00420             }
00421         }
00422         else {
00423             out << (*array)[i];
00424         }
00425     }
00426 
00427     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00428     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00429                       colList::iterator head, colList::iterator tail);
00430     virtual void sort(uint32_t i, uint32_t j,
00431                       array_t<uint32_t>& neworder) const;
00432     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00433     virtual void reorder(const array_t<uint32_t>& ind)
00434     {ibis::util::reorder(*array, ind);}
00435     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00436     {array->topk(k, ind);}
00437     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00438     {array->bottomk(k, ind);}
00439     virtual long truncate(uint32_t keep) {
00440         if (array == 0) return 0;
00441         if (array->size() > keep) {
00442             array->nosharing();
00443             array->resize(keep);
00444         }
00445         return array->size();
00446     }
00447 
00448     virtual double getMin() const;
00449     virtual double getMax() const;
00450     virtual double getSum() const;
00451     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00452     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00453     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00454     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00455     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00456     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00457 
00458 private:
00459     array_t<uint64_t>* array;
00460 
00461     colULongs(const colULongs&);
00462     colULongs& operator=(const colULongs&);
00463 }; // ibis::colULongs
00464 
00466 class FASTBIT_CXX_DLLSPEC ibis::colFloats : public ibis::colValues {
00467 public:
00468     colFloats() : colValues(), array(0) {};
00469     colFloats(const ibis::column* c, const ibis::bitvector& hits)
00470         : colValues(c), array(c->selectFloats(hits)) {}
00471     colFloats(const ibis::column* c, ibis::fileManager::storage* store,
00472               const uint32_t start, const uint32_t nelm)
00473         : colValues(c), array(new array_t<float>(store, start, nelm)) {}
00474     colFloats(const ibis::column* c, void* vals);
00475     virtual ~colFloats() {delete array;}
00476 
00477     virtual bool   empty() const {return (col==0 || array==0);}
00478     virtual uint32_t size() const {return (array ? array->size() : 0);}
00479     virtual uint32_t elementSize() const {return sizeof(float);}
00480     virtual ibis::TYPE_T getType() const {return ibis::FLOAT;}
00481     virtual void* getArray() const {return array;}
00482     virtual void nosharing() {array->nosharing();}
00483 
00484     virtual void   erase(uint32_t i, uint32_t j) {
00485         array->erase(array->begin()+i, array->begin()+j);}
00486     virtual void   swap(uint32_t i, uint32_t j) {
00487         float tmp = (*array)[i];
00488         (*array)[i] = (*array)[j];
00489         (*array)[j] = tmp;}
00490 
00491     void swap(colFloats& rhs) { // swap two colFloats
00492         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00493         array_t<float>* a = rhs.array; rhs.array = array; array = a;}
00494     virtual void   reduce(const array_t<uint32_t>& starts);
00495     virtual void   reduce(const array_t<uint32_t>& starts,
00496                           ibis::selectClause::AGREGADO func);
00497 
00498     // write out whole array as binary
00499     virtual uint32_t write(FILE* fptr) const {
00500         if (array) {
00501             uint32_t nelm = array->size();
00502             return nelm - fwrite(array->begin(), sizeof(float), nelm, fptr);
00503         }
00504         else {
00505             return 0;
00506         }
00507     }
00508     // write ith element as text
00509     virtual void write(std::ostream& out, uint32_t i) const {
00510         out << (*array)[i];}
00511 
00512     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00513     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00514                       colList::iterator head, colList::iterator tail);
00515     virtual void sort(uint32_t i, uint32_t j,
00516                       array_t<uint32_t>& neworder) const;
00517     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00518     virtual void reorder(const array_t<uint32_t>& ind)
00519     {ibis::util::reorder(*array, ind);}
00520     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00521     {array->topk(k, ind);}
00522     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00523     {array->bottomk(k, ind);}
00524     virtual long truncate(uint32_t keep) {
00525         if (array == 0) return 0;
00526         if (array->size() > keep) {
00527             array->nosharing();
00528             array->resize(keep);
00529         }
00530         return array->size();
00531     }
00532 
00533     virtual double getMin() const;
00534     virtual double getMax() const;
00535     virtual double getSum() const;
00536     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00537     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00538     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00539     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00540     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00541     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00542 
00543 private:
00544     array_t<float>* array;
00545 
00546     colFloats(const colFloats&);
00547     colFloats& operator=(const colFloats&);
00548 }; // ibis::colFloats
00549 
00551 class FASTBIT_CXX_DLLSPEC ibis::colDoubles : public ibis::colValues {
00552 public:
00553     colDoubles() : colValues(), array(0) {};
00554     colDoubles(const ibis::column* c, const ibis::bitvector& hits)
00555         : colValues(c), array(c->selectDoubles(hits)) {}
00556     colDoubles(const ibis::column* c, ibis::fileManager::storage* store,
00557                const uint32_t start, const uint32_t nelm)
00558         : colValues(c), array(new array_t<double>(store, start, nelm)) {}
00559     colDoubles(const ibis::column* c, void* vals);
00560     virtual ~colDoubles() {delete array;}
00561 
00562     virtual bool   empty() const {return (col==0 || array==0);}
00563     virtual uint32_t size() const {return (array ? array->size() : 0);}
00564     virtual uint32_t elementSize() const {return sizeof(double);}
00565     virtual ibis::TYPE_T getType() const {return ibis::DOUBLE;}
00566     virtual void* getArray() const {return array;}
00567     virtual void nosharing() {array->nosharing();}
00568 
00569     virtual void   erase(uint32_t i, uint32_t j) {
00570         array->erase(array->begin()+i, array->begin()+j);}
00571     virtual void   swap(uint32_t i, uint32_t j) {
00572         double tmp = (*array)[i]; (*array)[i] = (*array)[j];
00573         (*array)[j] = tmp;}
00574 
00575     void swap(colDoubles& rhs) { // swap two colDoubles
00576         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00577         array_t<double>* a = rhs.array; rhs.array = array; array = a;}
00578     virtual void   reduce(const array_t<uint32_t>& starts);
00579     virtual void   reduce(const array_t<uint32_t>& starts,
00580                           ibis::selectClause::AGREGADO func);
00581 
00582     // write out whole array as binary
00583     virtual uint32_t write(FILE* fptr) const {
00584         if (array) {
00585             uint32_t nelm = array->size();
00586             return nelm - fwrite(array->begin(), sizeof(double), nelm, fptr);
00587         }
00588         else {
00589             return 0;
00590         }
00591     }
00592     // write ith element as text
00593     virtual void write(std::ostream& out, uint32_t i) const {
00594         out.precision(12); out << (*array)[i];}
00595 
00596     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00597     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00598                       colList::iterator head, colList::iterator tail);
00599     virtual void sort(uint32_t i, uint32_t j,
00600                       array_t<uint32_t>& neworder) const;
00601     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00602     virtual void reorder(const array_t<uint32_t>& ind)
00603     {ibis::util::reorder(*array, ind);}
00604     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00605     {array->topk(k, ind);}
00606     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00607     {array->bottomk(k, ind);}
00608     virtual long truncate(uint32_t keep) {
00609         if (array == 0) return 0;
00610         if (array->size() > keep) {
00611             array->nosharing();
00612             array->resize(keep);
00613         }
00614         return array->size();
00615     }
00616 
00617     virtual double getMin() const;
00618     virtual double getMax() const;
00619     virtual double getSum() const;
00620     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00621     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00622     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00623     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00624     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00625     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00626 
00627 private:
00628     array_t<double>* array;
00629 
00630     colDoubles(const colDoubles&);
00631     colDoubles& operator=(const colDoubles&);
00632 }; // ibis::colDoubles
00633 
00635 class FASTBIT_CXX_DLLSPEC ibis::colStrings : public ibis::colValues {
00636 public:
00637     colStrings() : colValues(), array(0) {};
00638     colStrings(const ibis::column* c, const ibis::bitvector& hits)
00639         : colValues(c), array(c->selectStrings(hits)) {}
00640     colStrings(const ibis::column* c, void* vals);
00641     virtual ~colStrings() {delete array;}
00642 
00643     virtual bool         empty() const {return (col==0 || array==0);}
00644     virtual uint32_t     size() const {return (array ? array->size() : 0);}
00645     virtual uint32_t     elementSize() const {return 0;}
00646     virtual ibis::TYPE_T getType() const {return col->type();}
00647     virtual void*        getArray() const {return array;}
00648     virtual void         nosharing() {/* neve shared */}
00649 
00650     virtual void erase(uint32_t i, uint32_t j) {
00651         array->erase(array->begin()+i, array->begin()+j);}
00652     virtual void swap(uint32_t i, uint32_t j) {(*array)[i].swap((*array)[j]);}
00653 
00654     void swap(colStrings& rhs) { // swap two colStrings
00655         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00656         std::vector<std::string>* a = rhs.array; rhs.array = array; array = a;}
00657     virtual void   reduce(const array_t<uint32_t>& starts);
00658     virtual void   reduce(const array_t<uint32_t>& starts,
00659                           ibis::selectClause::AGREGADO func);
00660 
00661     // write out whole array as binary
00662     virtual uint32_t write(FILE* fptr) const;
00663     // write ith element as text
00664     virtual void write(std::ostream& out, uint32_t i) const {
00665         out << (*array)[i];}
00666 
00667     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00668     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00669                       colList::iterator head, colList::iterator tail);
00670     virtual void sort(uint32_t i, uint32_t j,
00671                       array_t<uint32_t>& neworder) const;
00672     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00673     virtual void reorder(const array_t<uint32_t>& ind);
00674     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const;
00675     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const;
00676     virtual long truncate(uint32_t keep) {
00677         if (array == 0) return 0;
00678         if (array->size() > keep) {
00679             array->resize(keep);
00680         }
00681         return array->size();
00682     }
00683 
00685     virtual double getMin() const {
00686         return std::numeric_limits<double>::quiet_NaN();}
00688     virtual double getMax() const {
00689         return std::numeric_limits<double>::quiet_NaN();}
00691     virtual double getSum() const {
00692         return std::numeric_limits<double>::quiet_NaN();}
00694     virtual int32_t getInt(uint32_t i) const {return 0;}
00696     virtual uint32_t getUInt(uint32_t i) const {return 0;}
00698     virtual int64_t getLong(uint32_t i) const {return 0;}
00700     virtual uint64_t getULong(uint32_t i) const {return 0;}
00702     virtual float getFloat(uint32_t i) const {
00703         return  std::numeric_limits<float>::quiet_NaN();}
00705     virtual double getDouble(uint32_t i) const {
00706         return std::numeric_limits<double>::quiet_NaN();}
00707 
00708 private:
00710     std::vector<std::string>* array;
00711 
00712     colStrings(const colStrings&);
00713     colStrings& operator=(const colStrings&);
00714 
00715     void sortsub(uint32_t i, uint32_t j, array_t<uint32_t>& ind) const;
00716     uint32_t partitionsub(uint32_t, uint32_t, array_t<uint32_t>&) const;
00717 }; // ibis::colStrings
00718 #endif


	Contact us Disclaimers FastBit source code FastBit mailing list archive