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-2012 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     const ibis::column* operator->() const {return col;}
00030     const ibis::column* columnPointer() const {return col;}
00032     const char* name() const {return(col!=0?col->name():0);}
00033 
00034     virtual bool empty() const = 0;
00035     virtual void reduce(const array_t<uint32_t>& starts) = 0;
00036     virtual void reduce(const array_t<uint32_t>& starts,
00037                         ibis::selectClause::AGREGADO func) = 0;
00038     virtual void erase(uint32_t i, uint32_t j) = 0;
00039     virtual void swap(uint32_t i, uint32_t j) = 0;
00040     virtual uint32_t size() const = 0;
00041     virtual uint32_t elementSize() const = 0;
00043     virtual ibis::TYPE_T getType() const =0;
00045     virtual void* getArray() const =0;
00047     virtual void nosharing() =0;
00048 
00049     bool canSort() const
00050     {return (col ? col->type() != ibis::TEXT : false);}
00051 
00052     void swap(colValues& rhs) { // swap two colValues
00053         const ibis::column* c = rhs.col;
00054         rhs.col = col;
00055         col = c;
00056     }
00057 
00059     virtual long write(FILE* fptr) const  = 0;
00061     virtual void write(std::ostream& out, uint32_t i) const = 0;
00062 
00064     virtual void sort(uint32_t i, uint32_t j, bundle* bdl) = 0;
00067     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00068                       colList::iterator head, colList::iterator tail) = 0;
00071     virtual void sort(uint32_t i, uint32_t j,
00072                       array_t<uint32_t>& neworder) const = 0;
00075     virtual void reorder(const array_t<uint32_t>& ind) = 0;
00078     virtual array_t<uint32_t>*
00079     segment(const array_t<uint32_t>* old=0) const = 0;
00081     virtual long truncate(uint32_t keep) = 0;
00083     virtual long truncate(uint32_t keep, uint32_t start) = 0;
00085     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const = 0;
00087     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const = 0;
00088 
00089     virtual double getMin() const = 0;
00090     virtual double getMax() const = 0;
00091     virtual double getSum() const = 0;
00092     virtual int32_t getInt(uint32_t) const = 0;
00093     virtual uint32_t getUInt(uint32_t) const = 0;
00094     virtual int64_t getLong(uint32_t) const = 0;
00095     virtual uint64_t getULong(uint32_t) const = 0;
00096     virtual float getFloat(uint32_t) const = 0;
00097     virtual double getDouble(uint32_t) const = 0;
00098 
00099 protected:
00100     const ibis::column* col; 
00101 
00102     colValues() : col(0) {}
00103     colValues(const ibis::column* c) : col(c) {};
00104 
00105 private:
00106     colValues& operator=(const colValues&);
00107 }; // ibis::colValues
00108 
00110 class FASTBIT_CXX_DLLSPEC ibis::colInts : public ibis::colValues {
00111 public:
00112     colInts() : colValues(), array(0) {};
00113     colInts(const ibis::column* c, const ibis::bitvector& hits)
00114         : colValues(c), array(c->selectInts(hits)) {}
00115     colInts(const ibis::column* c, ibis::fileManager::storage* store,
00116             const uint32_t start, const uint32_t nelm)
00117         : colValues(c), array(new array_t<int32_t>(store, start, nelm)) {}
00118     colInts(const ibis::column* c);
00119     virtual ~colInts() {delete array;}
00120 
00121     virtual bool   empty() const {return (col==0 || array==0);}
00122     virtual uint32_t size() const {return (array ? array->size() : 0);}
00123     virtual uint32_t elementSize() const {return sizeof(int32_t);}
00124     virtual ibis::TYPE_T getType() const {return ibis::INT;}
00125     virtual void* getArray() const {return array;}
00126     virtual void nosharing() {array->nosharing();}
00127 
00128     virtual void   reduce(const array_t<uint32_t>& starts);
00129     virtual void   reduce(const array_t<uint32_t>& starts,
00130                           ibis::selectClause::AGREGADO func);
00131     virtual void   erase(uint32_t i, uint32_t j) {
00132         array->erase(array->begin()+i, array->begin()+j);}
00133     virtual void   swap(uint32_t i, uint32_t j) {
00134         int32_t tmp = (*array)[i];
00135         (*array)[i] = (*array)[j];
00136         (*array)[j] = tmp;}
00137 
00138     void swap(colInts& rhs) { // swap two colInts
00139         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00140         array_t<int32_t>* a = rhs.array; rhs.array = array; array = a;}
00141 
00142     virtual long write(FILE* fptr) const;
00143     virtual void write(std::ostream& out, uint32_t i) const;
00144 
00145     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00146     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00147                       colList::iterator head, colList::iterator tail);
00148     virtual void sort(uint32_t i, uint32_t j,
00149                       array_t<uint32_t>& neworder) const;
00150     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00151     virtual void reorder(const array_t<uint32_t>& ind)
00152     {ibis::util::reorder(*array, ind);}
00153     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00154     {array->topk(k, ind);}
00155     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00156     {array->bottomk(k, ind);}
00157     virtual long truncate(uint32_t keep);
00158     virtual long truncate(uint32_t keep, uint32_t start);
00159 
00160     virtual double getMin() const;
00161     virtual double getMax() const;
00162     virtual double getSum() const;
00163     virtual int32_t getInt(uint32_t i) const {return (*array)[i];}
00164     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00165     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00166     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00167     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00168     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00169 
00170 private:
00171     array_t<int32_t>* array;
00172 
00173     colInts(const colInts&);
00174     colInts& operator=(const colInts&);
00175 }; // ibis::colInts
00176 
00178 class FASTBIT_CXX_DLLSPEC ibis::colUInts : public ibis::colValues {
00179 public:
00180     colUInts() : colValues(), array(0), dic(0) {};
00181     colUInts(const ibis::column* c, const ibis::bitvector& hits);
00182     colUInts(const ibis::column* c, ibis::fileManager::storage* store,
00183              const uint32_t start, const uint32_t nelm);
00184     colUInts(const ibis::column* c);
00185     virtual ~colUInts() {delete array;}
00186 
00187     virtual bool   empty() const {return (col==0 || array==0);}
00188     virtual uint32_t size() const {return (array ? array->size() : 0);}
00189     virtual uint32_t elementSize() const {return sizeof(uint32_t);}
00190     virtual ibis::TYPE_T getType() const {return ibis::UINT;}
00191     virtual void* getArray() const {return array;}
00192     virtual void nosharing() {array->nosharing();}
00193 
00194     virtual void   erase(uint32_t i, uint32_t j) {
00195         array->erase(array->begin()+i, array->begin()+j);}
00196     virtual void   swap(uint32_t i, uint32_t j) {
00197         uint32_t tmp = (*array)[i];
00198         (*array)[i] = (*array)[j];
00199         (*array)[j] = tmp;}
00200 
00201     virtual void   reduce(const array_t<uint32_t>& starts);
00202     virtual void   reduce(const array_t<uint32_t>& starts,
00203                           ibis::selectClause::AGREGADO func);
00204     void swap(colUInts& rhs) { // swap two colUInts
00205         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00206         array_t<uint32_t>* a = rhs.array; rhs.array = array; array = a;}
00207 
00208     virtual long write(FILE* fptr) const;
00209     virtual void write(std::ostream& out, uint32_t i) const;
00210 
00211     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00212     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00213                       colList::iterator head, colList::iterator tail);
00214     virtual void sort(uint32_t i, uint32_t j,
00215                       array_t<uint32_t>& neworder) const;
00216     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00217     virtual void reorder(const array_t<uint32_t>& ind)
00218     {ibis::util::reorder(*array, ind);}
00219     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00220     {array->topk(k, ind);}
00221     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00222     {array->bottomk(k, ind);}
00223     virtual long truncate(uint32_t keep);
00224     virtual long truncate(uint32_t keep, uint32_t start);
00225 
00226     virtual double getMin() const;
00227     virtual double getMax() const;
00228     virtual double getSum() const;
00229     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00230     virtual uint32_t getUInt(uint32_t i) const {return (*array)[i];}
00231     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00232     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00233     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00234     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00235 
00236 private:
00237     array_t<uint32_t>* array;
00238     const dictionary* dic;
00239 
00240     colUInts(const colUInts&);
00241     colUInts& operator=(const colUInts&);
00242 }; // ibis::colUInts
00243 
00245 class FASTBIT_CXX_DLLSPEC ibis::colLongs : public ibis::colValues {
00246 public:
00247     colLongs() : colValues(), array(0) {};
00248     colLongs(const ibis::column* c, const ibis::bitvector& hits)
00249         : colValues(c), array(c->selectLongs(hits)) {}
00250     colLongs(const ibis::column* c, ibis::fileManager::storage* store,
00251             const uint32_t start, const uint32_t nelm)
00252         : colValues(c), array(new array_t<int64_t>(store, start, nelm)) {}
00253     colLongs(const ibis::column* c);
00254     virtual ~colLongs() {delete array;}
00255 
00256     virtual bool   empty() const {return (col==0 || array==0);}
00257     virtual uint32_t size() const {return (array ? array->size() : 0);}
00258     virtual uint32_t elementSize() const {return sizeof(int64_t);}
00259     virtual ibis::TYPE_T getType() const {return ibis::LONG;}
00260     virtual void* getArray() const {return array;}
00261     virtual void nosharing() {array->nosharing();}
00262 
00263     virtual void   reduce(const array_t<uint32_t>& starts);
00264     virtual void   reduce(const array_t<uint32_t>& starts,
00265                           ibis::selectClause::AGREGADO func);
00266     virtual void   erase(uint32_t i, uint32_t j) {
00267         array->erase(array->begin()+i, array->begin()+j);}
00268     virtual void   swap(uint32_t i, uint32_t j) {
00269         int64_t tmp = (*array)[i];
00270         (*array)[i] = (*array)[j];
00271         (*array)[j] = tmp;}
00272 
00273     void swap(colLongs& rhs) { // swap two colLongs
00274         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00275         array_t<int64_t>* a = rhs.array; rhs.array = array; array = a;}
00276 
00277     virtual long write(FILE* fptr) const;
00278     virtual void write(std::ostream& out, uint32_t i) const;
00279 
00280     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00281     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00282                       colList::iterator head, colList::iterator tail);
00283     virtual void sort(uint32_t i, uint32_t j,
00284                       array_t<uint32_t>& neworder) const;
00285     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00286     virtual void reorder(const array_t<uint32_t>& ind)
00287     {ibis::util::reorder(*array, ind);}
00288     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00289     {array->topk(k, ind);}
00290     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00291     {array->bottomk(k, ind);}
00292     virtual long truncate(uint32_t keep);
00293     virtual long truncate(uint32_t keep, uint32_t start);
00294 
00295     virtual double getMin() const;
00296     virtual double getMax() const;
00297     virtual double getSum() const;
00298     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00299     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00300     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00301     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00302     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00303     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00304 
00305 private:
00306     array_t<int64_t>* array;
00307 
00308     colLongs(const colLongs&);
00309     colLongs& operator=(const colLongs&);
00310 }; // ibis::colLongs
00311 
00313 class FASTBIT_CXX_DLLSPEC ibis::colULongs : public ibis::colValues {
00314 public:
00315     colULongs() : colValues(), array(0) {};
00316     colULongs(const ibis::column* c, const ibis::bitvector& hits)
00317         : colValues(c), array(c->selectULongs(hits)) {}
00318     colULongs(const ibis::column* c, ibis::fileManager::storage* store,
00319             const uint32_t start, const uint32_t nelm)
00320         : colValues(c), array(new array_t<uint64_t>(store, start, nelm)) {}
00321     colULongs(const ibis::column* c);
00322     virtual ~colULongs() {delete array;}
00323 
00324     virtual bool   empty() const {return (col==0 || array==0);}
00325     virtual uint32_t size() const {return (array ? array->size() : 0);}
00326     virtual uint32_t elementSize() const {return sizeof(uint64_t);}
00327     virtual ibis::TYPE_T getType() const {return ibis::ULONG;}
00328     virtual void* getArray() const {return array;}
00329     virtual void nosharing() {array->nosharing();}
00330 
00331     virtual void   erase(uint32_t i, uint32_t j) {
00332         array->erase(array->begin()+i, array->begin()+j);}
00333     virtual void   swap(uint32_t i, uint32_t j) {
00334         uint64_t tmp = (*array)[i];
00335         (*array)[i] = (*array)[j];
00336         (*array)[j] = tmp;}
00337 
00338     virtual void   reduce(const array_t<uint32_t>& starts);
00339     virtual void   reduce(const array_t<uint32_t>& starts,
00340                           ibis::selectClause::AGREGADO func);
00341     void swap(colULongs& rhs) { // swap two colULongs
00342         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00343         array_t<uint64_t>* a = rhs.array; rhs.array = array; array = a;}
00344 
00345     virtual long write(FILE* fptr) const;
00346     virtual void write(std::ostream& out, uint32_t i) const;
00347 
00348     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00349     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00350                       colList::iterator head, colList::iterator tail);
00351     virtual void sort(uint32_t i, uint32_t j,
00352                       array_t<uint32_t>& neworder) const;
00353     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00354     virtual void reorder(const array_t<uint32_t>& ind)
00355     {ibis::util::reorder(*array, ind);}
00356     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00357     {array->topk(k, ind);}
00358     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00359     {array->bottomk(k, ind);}
00360     virtual long truncate(uint32_t keep);
00361     virtual long truncate(uint32_t keep, uint32_t start);
00362 
00363     virtual double getMin() const;
00364     virtual double getMax() const;
00365     virtual double getSum() const;
00366     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00367     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00368     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00369     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00370     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00371     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00372 
00373 private:
00374     array_t<uint64_t>* array;
00375 
00376     colULongs(const colULongs&);
00377     colULongs& operator=(const colULongs&);
00378 }; // ibis::colULongs
00379 
00381 class FASTBIT_CXX_DLLSPEC ibis::colShorts : public ibis::colValues {
00382 public:
00383     colShorts() : colValues(), array(0) {};
00384     colShorts(const ibis::column* c, const ibis::bitvector& hits)
00385         : colValues(c), array(c->selectShorts(hits)) {}
00386     colShorts(const ibis::column* c, ibis::fileManager::storage* store,
00387               const uint32_t start, const uint32_t nelm)
00388         : colValues(c), array(new array_t<int16_t>(store, start, nelm)) {}
00389     colShorts(const ibis::column* c);
00390     virtual ~colShorts() {delete array;}
00391 
00392     virtual bool   empty() const {return (col==0 || array==0);}
00393     virtual uint32_t size() const {return (array ? array->size() : 0);}
00394     virtual uint32_t elementSize() const {return sizeof(int16_t);}
00395     virtual ibis::TYPE_T getType() const {return ibis::SHORT;}
00396     virtual void* getArray() const {return array;}
00397     virtual void nosharing() {array->nosharing();}
00398 
00399     virtual void   reduce(const array_t<uint32_t>& starts);
00400     virtual void   reduce(const array_t<uint32_t>& starts,
00401                           ibis::selectClause::AGREGADO func);
00402     virtual void   erase(uint32_t i, uint32_t j) {
00403         array->erase(array->begin()+i, array->begin()+j);}
00404     virtual void   swap(uint32_t i, uint32_t j) {
00405         int16_t tmp = (*array)[i];
00406         (*array)[i] = (*array)[j];
00407         (*array)[j] = tmp;}
00408 
00409     void swap(colShorts& rhs) { // swap two colShorts
00410         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00411         array_t<int16_t>* a = rhs.array; rhs.array = array; array = a;}
00412 
00413     virtual long write(FILE* fptr) const;
00414     virtual void write(std::ostream& out, uint32_t i) const;
00415 
00416     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00417     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00418                       colList::iterator head, colList::iterator tail);
00419     virtual void sort(uint32_t i, uint32_t j,
00420                       array_t<uint32_t>& neworder) const;
00421     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00422     virtual void reorder(const array_t<uint32_t>& ind)
00423     {ibis::util::reorder(*array, ind);}
00424     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00425     {array->topk(k, ind);}
00426     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00427     {array->bottomk(k, ind);}
00428     virtual long truncate(uint32_t keep);
00429     virtual long truncate(uint32_t keep, uint32_t start);
00430 
00431     virtual double getMin() const;
00432     virtual double getMax() const;
00433     virtual double getSum() const;
00434     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00435     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00436     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00437     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00438     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00439     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00440 
00441 private:
00442     array_t<int16_t>* array;
00443 
00444     colShorts(const colShorts&);
00445     colShorts& operator=(const colShorts&);
00446 }; // ibis::colShorts
00447 
00449 class FASTBIT_CXX_DLLSPEC ibis::colUShorts : public ibis::colValues {
00450 public:
00451     colUShorts() : colValues(), array(0) {};
00452     colUShorts(const ibis::column* c, const ibis::bitvector& hits)
00453         : colValues(c), array(c->selectUShorts(hits)) {}
00454     colUShorts(const ibis::column* c, ibis::fileManager::storage* store,
00455             const uint32_t start, const uint32_t nelm)
00456         : colValues(c), array(new array_t<uint16_t>(store, start, nelm)) {}
00457     colUShorts(const ibis::column* c);
00458     virtual ~colUShorts() {delete array;}
00459 
00460     virtual bool   empty() const {return (col==0 || array==0);}
00461     virtual uint32_t size() const {return (array ? array->size() : 0);}
00462     virtual uint32_t elementSize() const {return sizeof(uint16_t);}
00463     virtual ibis::TYPE_T getType() const {return ibis::USHORT;}
00464     virtual void* getArray() const {return array;}
00465     virtual void nosharing() {array->nosharing();}
00466 
00467     virtual void   erase(uint32_t i, uint32_t j) {
00468         array->erase(array->begin()+i, array->begin()+j);}
00469     virtual void   swap(uint32_t i, uint32_t j) {
00470         uint16_t tmp = (*array)[i];
00471         (*array)[i] = (*array)[j];
00472         (*array)[j] = tmp;}
00473 
00474     virtual void   reduce(const array_t<uint32_t>& starts);
00475     virtual void   reduce(const array_t<uint32_t>& starts,
00476                           ibis::selectClause::AGREGADO func);
00477     void swap(colUShorts& rhs) { // swap two colUShorts
00478         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00479         array_t<uint16_t>* a = rhs.array; rhs.array = array; array = a;}
00480 
00481     virtual long write(FILE* fptr) const;
00482     virtual void write(std::ostream& out, uint32_t i) const;
00483 
00484     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00485     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00486                       colList::iterator head, colList::iterator tail);
00487     virtual void sort(uint32_t i, uint32_t j,
00488                       array_t<uint32_t>& neworder) const;
00489     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00490     virtual void reorder(const array_t<uint32_t>& ind)
00491     {ibis::util::reorder(*array, ind);}
00492     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00493     {array->topk(k, ind);}
00494     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00495     {array->bottomk(k, ind);}
00496     virtual long truncate(uint32_t keep);
00497     virtual long truncate(uint32_t keep, uint32_t start);
00498 
00499     virtual double getMin() const;
00500     virtual double getMax() const;
00501     virtual double getSum() const;
00502     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00503     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00504     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00505     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00506     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00507     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00508 
00509 private:
00510     array_t<uint16_t>* array;
00511 
00512     colUShorts(const colUShorts&);
00513     colUShorts& operator=(const colUShorts&);
00514 }; // ibis::colUShorts
00515 
00517 class FASTBIT_CXX_DLLSPEC ibis::colBytes : public ibis::colValues {
00518 public:
00519     colBytes() : colValues(), array(0) {};
00520     colBytes(const ibis::column* c, const ibis::bitvector& hits)
00521         : colValues(c), array(c->selectBytes(hits)) {}
00522     colBytes(const ibis::column* c, ibis::fileManager::storage* store,
00523             const uint32_t start, const uint32_t nelm)
00524         : colValues(c), array(new array_t<signed char>(store, start, nelm)) {}
00525     colBytes(const ibis::column* c);
00526     virtual ~colBytes() {delete array;}
00527 
00528     virtual bool   empty() const {return (col==0 || array==0);}
00529     virtual uint32_t size() const {return (array ? array->size() : 0);}
00530     virtual uint32_t elementSize() const {return sizeof(char);}
00531     virtual ibis::TYPE_T getType() const {return ibis::BYTE;}
00532     virtual void* getArray() const {return array;}
00533     virtual void nosharing() {array->nosharing();}
00534 
00535     virtual void   reduce(const array_t<uint32_t>& starts);
00536     virtual void   reduce(const array_t<uint32_t>& starts,
00537                           ibis::selectClause::AGREGADO func);
00538     virtual void   erase(uint32_t i, uint32_t j) {
00539         array->erase(array->begin()+i, array->begin()+j);}
00540     virtual void   swap(uint32_t i, uint32_t j) {
00541         signed char tmp = (*array)[i];
00542         (*array)[i] = (*array)[j];
00543         (*array)[j] = tmp;}
00544 
00545     void swap(colBytes& rhs) { // swap two colBytes
00546         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00547         array_t<signed char>* a = rhs.array; rhs.array = array; array = a;}
00548 
00549     virtual long write(FILE* fptr) const;
00550     virtual void write(std::ostream& out, uint32_t i) const;
00551 
00552     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00553     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00554                       colList::iterator head, colList::iterator tail);
00555     virtual void sort(uint32_t i, uint32_t j,
00556                       array_t<uint32_t>& neworder) const;
00557     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00558     virtual void reorder(const array_t<uint32_t>& ind)
00559     {ibis::util::reorder(*array, ind);}
00560     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00561     {array->topk(k, ind);}
00562     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00563     {array->bottomk(k, ind);}
00564     virtual long truncate(uint32_t keep);
00565     virtual long truncate(uint32_t keep, uint32_t start);
00566 
00567     virtual double getMin() const;
00568     virtual double getMax() const;
00569     virtual double getSum() const;
00570     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00571     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00572     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00573     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00574     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00575     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00576 
00577 private:
00578     array_t<signed char>* array;
00579 
00580     colBytes(const colBytes&);
00581     colBytes& operator=(const colBytes&);
00582 }; // ibis::colBytes
00583 
00585 class FASTBIT_CXX_DLLSPEC ibis::colUBytes : public ibis::colValues {
00586 public:
00587     colUBytes() : colValues(), array(0) {};
00588     colUBytes(const ibis::column* c, const ibis::bitvector& hits)
00589         : colValues(c), array(c->selectUBytes(hits)) {}
00590     colUBytes(const ibis::column* c, ibis::fileManager::storage* store,
00591             const uint32_t start, const uint32_t nelm)
00592         : colValues(c), array(new array_t<unsigned char>(store, start, nelm)) {}
00593     colUBytes(const ibis::column* c);
00594     virtual ~colUBytes() {delete array;}
00595 
00596     virtual bool   empty() const {return (col==0 || array==0);}
00597     virtual uint32_t size() const {return (array ? array->size() : 0);}
00598     virtual uint32_t elementSize() const {return sizeof(char);}
00599     virtual ibis::TYPE_T getType() const {return ibis::UBYTE;}
00600     virtual void* getArray() const {return array;}
00601     virtual void nosharing() {array->nosharing();}
00602 
00603     virtual void   erase(uint32_t i, uint32_t j) {
00604         array->erase(array->begin()+i, array->begin()+j);}
00605     virtual void   swap(uint32_t i, uint32_t j) {
00606         unsigned char tmp = (*array)[i];
00607         (*array)[i] = (*array)[j];
00608         (*array)[j] = tmp;}
00609 
00610     virtual void   reduce(const array_t<uint32_t>& starts);
00611     virtual void   reduce(const array_t<uint32_t>& starts,
00612                           ibis::selectClause::AGREGADO func);
00613     void swap(colUBytes& rhs) { // swap two colUBytes
00614         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00615         array_t<unsigned char>* a = rhs.array; rhs.array = array; array = a;}
00616 
00617     virtual long write(FILE* fptr) const;
00618     virtual void write(std::ostream& out, uint32_t i) const;
00619 
00620     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00621     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00622                       colList::iterator head, colList::iterator tail);
00623     virtual void sort(uint32_t i, uint32_t j,
00624                       array_t<uint32_t>& neworder) const;
00625     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00626     virtual void reorder(const array_t<uint32_t>& ind)
00627     {ibis::util::reorder(*array, ind);}
00628     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00629     {array->topk(k, ind);}
00630     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00631     {array->bottomk(k, ind);}
00632     virtual long truncate(uint32_t keep);
00633     virtual long truncate(uint32_t keep, uint32_t start);
00634 
00635     virtual double getMin() const;
00636     virtual double getMax() const;
00637     virtual double getSum() const;
00638     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00639     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00640     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00641     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00642     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00643     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00644 
00645 private:
00646     array_t<unsigned char>* array;
00647 
00648     colUBytes(const colUBytes&);
00649     colUBytes& operator=(const colUBytes&);
00650 }; // ibis::colUBytes
00651 
00653 class FASTBIT_CXX_DLLSPEC ibis::colFloats : public ibis::colValues {
00654 public:
00655     colFloats() : colValues(), array(0) {};
00656     colFloats(const ibis::column* c, const ibis::bitvector& hits)
00657         : colValues(c), array(c->selectFloats(hits)) {}
00658     colFloats(const ibis::column* c, ibis::fileManager::storage* store,
00659               const uint32_t start, const uint32_t nelm)
00660         : colValues(c), array(new array_t<float>(store, start, nelm)) {}
00661     colFloats(const ibis::column* c);
00662     virtual ~colFloats() {delete array;}
00663 
00664     virtual bool   empty() const {return (col==0 || array==0);}
00665     virtual uint32_t size() const {return (array ? array->size() : 0);}
00666     virtual uint32_t elementSize() const {return sizeof(float);}
00667     virtual ibis::TYPE_T getType() const {return ibis::FLOAT;}
00668     virtual void* getArray() const {return array;}
00669     virtual void nosharing() {array->nosharing();}
00670 
00671     virtual void   erase(uint32_t i, uint32_t j) {
00672         array->erase(array->begin()+i, array->begin()+j);}
00673     virtual void   swap(uint32_t i, uint32_t j) {
00674         float tmp = (*array)[i];
00675         (*array)[i] = (*array)[j];
00676         (*array)[j] = tmp;}
00677 
00678     void swap(colFloats& rhs) { // swap two colFloats
00679         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00680         array_t<float>* a = rhs.array; rhs.array = array; array = a;}
00681     virtual void   reduce(const array_t<uint32_t>& starts);
00682     virtual void   reduce(const array_t<uint32_t>& starts,
00683                           ibis::selectClause::AGREGADO func);
00684 
00685     virtual long write(FILE* fptr) const;
00686     virtual void write(std::ostream& out, uint32_t i) const;
00687 
00688     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00689     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00690                       colList::iterator head, colList::iterator tail);
00691     virtual void sort(uint32_t i, uint32_t j,
00692                       array_t<uint32_t>& neworder) const;
00693     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00694     virtual void reorder(const array_t<uint32_t>& ind)
00695     {ibis::util::reorder(*array, ind);}
00696     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00697     {array->topk(k, ind);}
00698     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00699     {array->bottomk(k, ind);}
00700     virtual long truncate(uint32_t keep);
00701     virtual long truncate(uint32_t keep, uint32_t start);
00702 
00703     virtual double getMin() const;
00704     virtual double getMax() const;
00705     virtual double getSum() const;
00706     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00707     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00708     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00709     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00710     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00711     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00712 
00713 private:
00714     array_t<float>* array;
00715 
00716     colFloats(const colFloats&);
00717     colFloats& operator=(const colFloats&);
00718 }; // ibis::colFloats
00719 
00721 class FASTBIT_CXX_DLLSPEC ibis::colDoubles : public ibis::colValues {
00722 public:
00723     colDoubles() : colValues(), array(0) {};
00724     colDoubles(const ibis::column* c, const ibis::bitvector& hits)
00725         : colValues(c), array(c->selectDoubles(hits)) {}
00726     colDoubles(const ibis::column* c, ibis::fileManager::storage* store,
00727                const uint32_t start, const uint32_t end)
00728         : colValues(c), array(new array_t<double>(store, start, end)) {}
00729     colDoubles(const ibis::column* c);
00730     colDoubles(size_t n, double v) : array(new array_t<double>(n, v)) {}
00731     virtual ~colDoubles() {delete array;}
00732 
00733     virtual bool   empty() const {return (col==0 || array==0);}
00734     virtual uint32_t size() const {return (array ? array->size() : 0);}
00735     virtual uint32_t elementSize() const {return sizeof(double);}
00736     virtual ibis::TYPE_T getType() const {return ibis::DOUBLE;}
00737     virtual void* getArray() const {return array;}
00738     virtual void nosharing() {array->nosharing();}
00739 
00740     virtual void   erase(uint32_t i, uint32_t j) {
00741         array->erase(array->begin()+i, array->begin()+j);}
00742     virtual void   swap(uint32_t i, uint32_t j) {
00743         double tmp = (*array)[i];
00744         (*array)[i] = (*array)[j];
00745         (*array)[j] = tmp;}
00746 
00747     void swap(colDoubles& rhs) { // swap two colDoubles
00748         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00749         array_t<double>* a = rhs.array; rhs.array = array; array = a;}
00750     virtual void   reduce(const array_t<uint32_t>& starts);
00751     virtual void   reduce(const array_t<uint32_t>& starts,
00752                           ibis::selectClause::AGREGADO func);
00753 
00754     virtual long write(FILE* fptr) const;
00755     virtual void write(std::ostream& out, uint32_t i) const;
00756 
00757     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00758     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00759                       colList::iterator head, colList::iterator tail);
00760     virtual void sort(uint32_t i, uint32_t j,
00761                       array_t<uint32_t>& neworder) const;
00762     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00763     virtual void reorder(const array_t<uint32_t>& ind)
00764     {ibis::util::reorder(*array, ind);}
00765     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00766     {array->topk(k, ind);}
00767     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00768     {array->bottomk(k, ind);}
00769     virtual long truncate(uint32_t keep);
00770     virtual long truncate(uint32_t keep, uint32_t start);
00771 
00772     virtual double getMin() const;
00773     virtual double getMax() const;
00774     virtual double getSum() const;
00775     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00776     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00777     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00778     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00779     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00780     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00781 
00782 private:
00783     array_t<double>* array;
00784 
00785     colDoubles(const colDoubles&);
00786     colDoubles& operator=(const colDoubles&);
00787 }; // ibis::colDoubles
00788 
00790 class FASTBIT_CXX_DLLSPEC ibis::colStrings : public ibis::colValues {
00791 public:
00792     colStrings() : colValues(), array(0) {};
00793     colStrings(const ibis::column* c, const ibis::bitvector& hits)
00794         : colValues(c), array(c->selectStrings(hits)) {}
00795     colStrings(const ibis::column* c);
00796     colStrings(size_t n, const std::string& v)
00797         : array(new std::vector<std::string>(n, v)) {}
00798     virtual ~colStrings() {delete array;}
00799 
00800     virtual bool         empty() const {return (col==0 || array==0);}
00801     virtual uint32_t     size() const {return (array ? array->size() : 0);}
00802     virtual uint32_t     elementSize() const {return 0;}
00803     virtual ibis::TYPE_T getType() const {return col->type();}
00804     virtual void*        getArray() const {return array;}
00805     virtual void         nosharing() {/* neve shared */}
00806 
00807     virtual void erase(uint32_t i, uint32_t j) {
00808         array->erase(array->begin()+i, array->begin()+j);}
00809     virtual void swap(uint32_t i, uint32_t j) {(*array)[i].swap((*array)[j]);}
00810 
00811     void swap(colStrings& rhs) { // swap two colStrings
00812         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00813         std::vector<std::string>* a = rhs.array; rhs.array = array; array = a;}
00814     virtual void reduce(const array_t<uint32_t>& starts);
00815     virtual void reduce(const array_t<uint32_t>& starts,
00816                         ibis::selectClause::AGREGADO func);
00817 
00818     virtual long write(FILE* fptr) const;
00819     virtual void write(std::ostream& out, uint32_t i) const;
00820 
00821     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00822     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00823                       colList::iterator head, colList::iterator tail);
00824     virtual void sort(uint32_t i, uint32_t j,
00825                       array_t<uint32_t>& neworder) const;
00826     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00827     virtual void reorder(const array_t<uint32_t>& ind);
00828     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const;
00829     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const;
00830     virtual long truncate(uint32_t keep);
00831     virtual long truncate(uint32_t keep, uint32_t start);
00832 
00834     virtual double getMin() const {return FASTBIT_DOUBLE_NULL;}
00836     virtual double getMax() const {return FASTBIT_DOUBLE_NULL;}
00838     virtual double getSum() const {return FASTBIT_DOUBLE_NULL;}
00840     virtual int32_t getInt(uint32_t) const {return 0;}
00842     virtual uint32_t getUInt(uint32_t) const {return 0;}
00844     virtual int64_t getLong(uint32_t) const {return 0;}
00846     virtual uint64_t getULong(uint32_t) const {return 0;}
00848     virtual float getFloat(uint32_t) const {return  FASTBIT_FLOAT_NULL;}
00850     virtual double getDouble(uint32_t) const {return FASTBIT_DOUBLE_NULL;}
00851 
00852 private:
00854     std::vector<std::string>* array;
00855 
00856     colStrings(const colStrings&);
00857     colStrings& operator=(const colStrings&);
00858 
00859     void sortsub(uint32_t i, uint32_t j, array_t<uint32_t>& ind) const;
00860     uint32_t partitionsub(uint32_t, uint32_t, array_t<uint32_t>&) const;
00861 }; // ibis::colStrings
00862 #endif

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