tab.h
Go to the documentation of this file.
00001 // File: $Id$
00002 // Author: John Wu <John.Wu at ACM.org>
00003 // Copyright 2007-2012 the Regents of the University of California
00004 #ifndef IBIS_TAB_H
00005 #define IBIS_TAB_H
00006 
00020 #include "table.h"      // ibis::table
00021 #include "array_t.h"    // ibis::array_t
00022 #include <iostream>
00023 
00024 namespace ibis {
00025     class tabula;
00026     class tabele;
00027 } // namespace ibis
00028 
00032 class ibis::tabula : public ibis::table {
00033 public:
00034     tabula(const char* na, const char* de, uint64_t nr) :
00035         table(na, de), nrows(nr) {};
00036     explicit tabula(uint64_t nr=0) : nrows(nr) {};
00037     virtual ~tabula() {};
00038     virtual uint64_t nRows() const {return nrows;}
00039     virtual uint32_t nColumns() const {return 0;}
00040 
00041     virtual stringList columnNames() const;
00042     virtual typeList columnTypes() const;
00043 
00044     virtual void describe(std::ostream&) const;
00045     virtual void dumpNames(std::ostream&, const char*) const {}
00046     virtual int dump(std::ostream&, const char*) const {return 0;}
00047     virtual int dump(std::ostream&, uint64_t, const char*) const {return 0;}
00048     virtual int dump(std::ostream&, uint64_t, uint64_t, const char*) const {
00049         return 0;}
00051     virtual int backup(const char*, const char* =0,
00052                        const char* =0) const {return 0;}
00053 
00054     virtual int64_t
00055     getColumnAsBytes(const char*, char*, uint64_t =0,
00056                      uint64_t =0) const {return -1;}
00057     virtual int64_t
00058     getColumnAsUBytes(const char*, unsigned char*, uint64_t =0,
00059                       uint64_t =0) const {return -1;}
00060     virtual int64_t
00061     getColumnAsShorts(const char*, int16_t*, uint64_t =0,
00062                       uint64_t =0) const {return -1;}
00063     virtual int64_t
00064     getColumnAsUShorts(const char*, uint16_t*, uint64_t =0,
00065                        uint64_t =0) const {return -1;}
00066     virtual int64_t
00067     getColumnAsInts(const char*, int32_t*, uint64_t =0,
00068                     uint64_t =0) const {return -1;}
00069     virtual int64_t
00070     getColumnAsUInts(const char*, uint32_t*, uint64_t =0,
00071                      uint64_t =0) const {return -1;}
00072     virtual int64_t
00073     getColumnAsLongs(const char*, int64_t*, uint64_t =0,
00074                      uint64_t =0) const {return -1;}
00075     virtual int64_t
00076     getColumnAsULongs(const char*, uint64_t*, uint64_t =0,
00077                       uint64_t =0) const {return -1;}
00078     virtual int64_t
00079     getColumnAsFloats(const char*, float*, uint64_t =0,
00080                       uint64_t =0) const {return -1;}
00081     virtual int64_t
00082     getColumnAsDoubles(const char*, double*, uint64_t =0,
00083                        uint64_t =0) const {return -1;}
00084     virtual int64_t
00085     getColumnAsDoubles(const char*, std::vector<double>&, uint64_t =0,
00086                        uint64_t =0) const {return -1;}
00087     virtual int64_t
00088     getColumnAsStrings(const char*, std::vector<std::string>&, uint64_t =0,
00089                        uint64_t =0) const {return -1;}
00090     virtual double getColumnMin(const char*) const {
00091         return DBL_MAX;}
00092     virtual double getColumnMax(const char*) const {
00093         return -DBL_MAX;}
00094 
00095     virtual long getHistogram(const char*, const char*,
00096                               double, double, double,
00097                               std::vector<uint32_t>&) const {return -1;}
00098     virtual long getHistogram2D(const char*, const char*,
00099                                 double, double, double,
00100                                 const char*,
00101                                 double, double, double,
00102                                 std::vector<uint32_t>&) const {return -1;}
00103     virtual long getHistogram3D(const char*, const char*,
00104                                 double, double, double,
00105                                 const char*,
00106                                 double, double, double,
00107                                 const char*,
00108                                 double, double, double,
00109                                 std::vector<uint32_t>&) const {return -1;}
00110 
00111     virtual void estimate(const char* cond,
00112                           uint64_t& nmin, uint64_t& nmax) const;
00113     virtual void estimate(const ibis::qExpr* cond,
00114                           uint64_t& nmin, uint64_t& nmax) const;
00115     using ibis::table::select;
00116     virtual table* select(const char*, const char*) const {return 0;}
00117 
00118     virtual table* groupby(const stringList&) const {return 0;}
00119     virtual table* groupby(const char*) const {return 0;}
00120     virtual void orderby(const stringList&, const std::vector<bool>&) {};
00121     virtual void orderby(const stringList&) {};
00122     virtual void orderby(const char*) {};
00123     virtual void reverseRows() {};
00124 
00125     virtual int buildIndex(const char*, const char*) {return -1;}
00126     virtual int buildIndexes(const char*) {return -1;}
00127     virtual const char* indexSpec(const char*) const {return 0;}
00128     virtual void indexSpec(const char*, const char*) {return;}
00129 
00130     // Cursor class for row-wise data accesses.
00131     class cursor;
00133     virtual ibis::table::cursor* createCursor() const;
00134 
00135 private:
00137     uint64_t nrows;
00138 
00139     tabula(const tabula&);
00140     tabula& operator=(const tabula&);
00141 }; // ibis::tabula
00142 
00148 class ibis::tabele : public ibis::table {
00149 public:
00152     tabele(const char* na, const char* de, uint64_t nr, const char* nm=0) :
00153         table(na, de), nrows(nr), col(nm && *nm ? nm : "nrows") {};
00157     explicit tabele(uint64_t nr=0, const char* nm=0) :
00158         nrows(nr), col(nm && *nm ? nm : "nrows") {};
00159     virtual ~tabele() {};
00160     virtual uint64_t nRows() const {return 1U;}
00161     virtual uint32_t nColumns() const {return 1U;}
00162 
00163     virtual stringList columnNames() const;
00164     virtual typeList columnTypes() const;
00165 
00166     virtual void describe(std::ostream&) const;
00167     virtual void dumpNames(std::ostream&, const char*) const;
00168     virtual int dump(std::ostream&, const char*) const;
00169     virtual int dump(std::ostream& out, uint64_t nr, const char* sep) const {
00170         if (nr > 0) return dump(out, sep); else return 0;}
00171     virtual int dump(std::ostream& out, uint64_t off, uint64_t nr,
00172                      const char* sep) const {
00173         if (off==0 && nr > 0) return dump(out, sep); else return 0;}
00175     virtual int backup(const char*, const char* =0,
00176                        const char* =0) const {return 0;}
00177 
00178     virtual int64_t getColumnAsBytes(const char*, char*, uint64_t =0,
00179                                      uint64_t =0) const {return -1;}
00180     virtual int64_t getColumnAsUBytes(const char*,
00181                                       unsigned char*, uint64_t =0,
00182                                       uint64_t =0) const {return -1;}
00183     virtual int64_t getColumnAsShorts(const char*,
00184                                       int16_t*, uint64_t =0,
00185                                       uint64_t =0) const {return -1;}
00186     virtual int64_t getColumnAsUShorts(const char*,
00187                                        uint16_t*, uint64_t =0,
00188                                        uint64_t =0) const {return -1;}
00189     virtual int64_t getColumnAsInts(const char*, int32_t*, uint64_t =0,
00190                                     uint64_t =0) const {return -1;}
00191     virtual int64_t getColumnAsUInts(const char* cn, uint32_t* vals,
00192                                      uint64_t begin =0, uint64_t =0) const {
00193         if (stricmp(col.c_str(), cn) == 0) {
00194             if (begin == 0) {
00195                 *vals = static_cast<uint32_t>(nrows);
00196                 return 1;
00197             }
00198             else {
00199                 return 0;
00200             }
00201         }
00202         else {
00203             return -1;
00204         }
00205     }
00206     virtual int64_t getColumnAsLongs(const char* cn, int64_t* vals,
00207                                      uint64_t begin =0, uint64_t =0) const {
00208         if (stricmp(col.c_str(), cn) == 0) {
00209             if (begin == 0) {
00210                 *vals = nrows;
00211                 return 1;
00212             }
00213             else {
00214                 return 0;
00215             }
00216         }
00217         else {
00218             return -1;
00219         }
00220     }
00221     virtual int64_t getColumnAsULongs(const char* cn, uint64_t* vals,
00222                                       uint64_t begin =0, uint64_t =0) const {
00223         if (stricmp(col.c_str(), cn) == 0) {
00224             if (begin == 0) {
00225                 *vals = nrows;
00226                 return 1;
00227             }
00228             else {
00229                 return 0;
00230             }
00231         }
00232         else {
00233             return -1;
00234         }
00235     }
00236     virtual int64_t getColumnAsFloats(const char*, float*, uint64_t =0,
00237                                       uint64_t =0) const {return -1;}
00238     virtual int64_t getColumnAsDoubles(const char*, double*, uint64_t =0,
00239                                      uint64_t =0) const {return -1;}
00240     virtual int64_t
00241     getColumnAsDoubles(const char*, std::vector<double>&, uint64_t =0,
00242                        uint64_t =0) const {return -1;}
00243     virtual int64_t
00244     getColumnAsStrings(const char*, std::vector<std::string>&, uint64_t =0,
00245                        uint64_t =0) const {return -1;}
00246     virtual double getColumnMin(const char* cn) const {
00247         if (stricmp(cn, col.c_str()) == 0)
00248             return nrows;
00249         else
00250             return DBL_MAX;
00251     }
00252     virtual double getColumnMax(const char* cn) const {
00253         if (stricmp(cn, col.c_str()) == 0)
00254             return nrows;
00255         else
00256             return -DBL_MAX;
00257     }
00258 
00259     virtual long getHistogram(const char*, const char*,
00260                               double, double, double,
00261                               std::vector<uint32_t>&) const {return -1;}
00262     virtual long getHistogram2D(const char*, const char*,
00263                                 double, double, double,
00264                                 const char*,
00265                                 double, double, double,
00266                                 std::vector<uint32_t>&) const {return -1;}
00267     virtual long getHistogram3D(const char*, const char*,
00268                                 double, double, double,
00269                                 const char*,
00270                                 double, double, double,
00271                                 const char*,
00272                                 double, double, double,
00273                                 std::vector<uint32_t>&) const {return -1;}
00274 
00275     virtual void estimate(const char* cond,
00276                           uint64_t& nmin, uint64_t& nmax) const;
00277     virtual void estimate(const ibis::qExpr* cond,
00278                           uint64_t& nmin, uint64_t& nmax) const;
00279     using ibis::table::select;
00280     virtual table* select(const char*, const char*) const {return 0;}
00281 
00282     virtual table* groupby(const stringList&) const {return 0;}
00283     virtual table* groupby(const char*) const {return 0;}
00284     virtual void orderby(const stringList&, const std::vector<bool>&) {};
00285     virtual void orderby(const stringList&) {};
00286     virtual void orderby(const char*) {};
00287     virtual void reverseRows() {};
00288 
00289     virtual int buildIndex(const char*, const char*) {return -1;}
00290     virtual int buildIndexes(const char*) {return -1;}
00291     virtual const char* indexSpec(const char*) const {return 0;}
00292     virtual void indexSpec(const char*, const char*) {return;}
00293 
00294     // Cursor class for row-wise data accesses.
00295     class cursor;
00297     virtual ibis::table::cursor* createCursor() const;
00298 
00299     const char* colName() const {return col.c_str();}
00300 
00301 private:
00302     // the number of rows selected
00303     uint64_t nrows;
00304     // the name of the column
00305     std::string col;
00306 
00307     tabele(const tabele&);
00308     tabele& operator=(const tabele&);
00309 
00310     friend class cursor;
00311 }; // ibis::tabele
00312 
00313 // Inline functions
00314 inline ibis::table::stringList ibis::tabula::columnNames() const {
00315     ibis::table::stringList tmp;
00316     return tmp;
00317 }
00318 
00319 inline ibis::table::typeList ibis::tabula::columnTypes() const {
00320     ibis::table::typeList tmp;
00321     return tmp;
00322 }
00323 
00324 inline void ibis::tabula::describe(std::ostream& out) const {
00325     out << "Table " << name_ << " (" << desc_ << ") contains "
00326         << nrows << " row" << (nrows > 1 ? "s" : "")
00327         << " but no columns" << std::endl;
00328 }
00329 
00330 inline void
00331 ibis::tabula::estimate(const char*, uint64_t& nmin, uint64_t& nmax) const {
00332     nmin = 0;
00333     nmax = nrows;
00334 }
00335 
00336 inline void
00337 ibis::tabula::estimate(const ibis::qExpr*,
00338                        uint64_t& nmin, uint64_t& nmax) const {
00339     nmin = 0;
00340     nmax = nrows;
00341 }
00342 
00343 class ibis::tabula::cursor : public ibis::table::cursor {
00344 public:
00345     cursor(const ibis::tabula& t) : tab(t) {}
00346     virtual ~cursor() {};
00347 
00348     virtual uint64_t nRows() const {return tab.nRows();}
00349     virtual uint32_t nColumns() const {return tab.nColumns();}
00350     virtual ibis::table::stringList columnNames() const {
00351         return tab.columnNames();}
00352     virtual ibis::table::typeList columnTypes() const {
00353         return tab.columnTypes();}
00354     virtual int fetch() {return -1;}
00355     virtual int fetch(uint64_t) {return -1;}
00356     virtual int fetch(ibis::table::row&) {return -1;}
00357     virtual int fetch(uint64_t, ibis::table::row&) {return -1;}
00358     virtual uint64_t getCurrentRowNumber() const {return tab.nRows();}
00359     virtual int dump(std::ostream&, const char* del) const {return 0;}
00360 
00361     virtual int getColumnAsByte(const char*, char&) const {return -1;}
00362     virtual int getColumnAsUByte(const char*, unsigned char&) const
00363     {return -1;}
00364     virtual int getColumnAsShort(const char*, int16_t&) const {return -1;}
00365     virtual int getColumnAsUShort(const char*, uint16_t&) const {return -1;}
00366     virtual int getColumnAsInt(const char*, int32_t&) const {return -1;}
00367     virtual int getColumnAsUInt(const char*, uint32_t&) const {return -1;}
00368     virtual int getColumnAsLong(const char*, int64_t&) const {return -1;}
00369     virtual int getColumnAsULong(const char*, uint64_t&) const {return -1;}
00370     virtual int getColumnAsFloat(const char*, float&) const {return -1;}
00371     virtual int getColumnAsDouble(const char*, double&) const {return -1;}
00372     virtual int getColumnAsString(const char*, std::string&) const {return -1;}
00373 
00374     virtual int getColumnAsByte(uint32_t, char&) const {return -1;}
00375     virtual int getColumnAsUByte(uint32_t, unsigned char&) const {return -1;}
00376     virtual int getColumnAsShort(uint32_t, int16_t&) const {return -1;}
00377     virtual int getColumnAsUShort(uint32_t, uint16_t&) const {return -1;}
00378     virtual int getColumnAsInt(uint32_t, int32_t&) const {return -1;}
00379     virtual int getColumnAsUInt(uint32_t, uint32_t&) const {return -1;}
00380     virtual int getColumnAsLong(uint32_t, int64_t&) const {return -1;}
00381     virtual int getColumnAsULong(uint32_t, uint64_t&) const {return -1;}
00382     virtual int getColumnAsFloat(uint32_t, float&) const {return -1;}
00383     virtual int getColumnAsDouble(uint32_t, double&) const {return -1;}
00384     virtual int getColumnAsString(uint32_t, std::string&) const {return -1;}
00385 
00386 private:
00387     const ibis::tabula& tab;
00388 
00389     cursor();
00390     cursor(const cursor&);
00391     cursor& operator=(const cursor&);
00392 }; // ibis::tabula::cursor
00393 
00394 inline ibis::table::cursor* ibis::tabula::createCursor() const {
00395     return new ibis::tabula::cursor(*this);
00396 } // ibis::tabula::createCursor
00397 
00398 inline ibis::table::stringList ibis::tabele::columnNames() const {
00399     ibis::table::stringList tmp(1);
00400     tmp[0] = col.c_str();
00401     return tmp;
00402 }
00403 
00404 inline ibis::table::typeList ibis::tabele::columnTypes() const {
00405     ibis::table::typeList tmp(1);
00406     tmp[0] = ibis::ULONG;
00407     return tmp;
00408 }
00409 
00410 inline void ibis::tabele::describe(std::ostream& out) const {
00411     out << "Table " << name_ << " (" << desc_
00412         << ") contains 1 column and 1 row\n"
00413         << col << "\t" << ibis::TYPESTRING[(int)ibis::ULONG] << "\n"
00414         << std::endl;
00415 }
00416 
00417 inline void ibis::tabele::dumpNames(std::ostream& out, const char*) const {
00418     out << col << std::endl;
00419 }
00420 
00421 inline int ibis::tabele::dump(std::ostream& out, const char *) const {
00422     out << nrows << std::endl;
00423     return 0;
00424 }
00425 
00426 inline void
00427 ibis::tabele::estimate(const char*, uint64_t& nmin, uint64_t& nmax) const {
00428     nmin = 0;
00429     nmax = 1;
00430 }
00431 
00432 inline void
00433 ibis::tabele::estimate(const ibis::qExpr*,
00434                        uint64_t& nmin, uint64_t& nmax) const {
00435     nmin = 0;
00436     nmax = 1;
00437 }
00438 
00439 class ibis::tabele::cursor : public ibis::table::cursor {
00440 public:
00441     cursor(const ibis::tabele& t) : tab(t), current(-1) {}
00442     virtual ~cursor() {};
00443 
00444     virtual uint64_t nRows() const {return tab.nRows();}
00445     virtual uint32_t nColumns() const {return tab.nColumns();}
00446     virtual ibis::table::stringList columnNames() const {
00447         return tab.columnNames();}
00448     virtual ibis::table::typeList columnTypes() const {
00449         return tab.columnTypes();}
00450     virtual int fetch() {
00451         ++ current;
00452         return (static_cast<uint64_t>(current) < tab.nRows() ? 0 : -1);}
00453     virtual int fetch(uint64_t irow) {
00454         if (irow < tab.nRows()) {
00455             current = irow;
00456             return 0;
00457         }
00458         else {
00459             return -1;
00460         }}
00461     virtual int fetch(ibis::table::row& res) {
00462         ++ current;
00463         res.clear();
00464         if (current == 0) {
00465             res.ulongsnames.push_back(tab.col);
00466             res.ulongsvalues.push_back(tab.nrows);
00467             return 0;
00468         }
00469         else {
00470             return -1;
00471         }
00472     }
00473     virtual int fetch(uint64_t irow, ibis::table::row& res) {
00474         res.clear();
00475         if (irow < 1U) {
00476             current = 0U;
00477             res.ulongsnames.push_back(tab.col);
00478             res.ulongsvalues.push_back(tab.nrows);
00479             return 0;
00480         }
00481         else {
00482             return -1;
00483         }
00484     }
00485     virtual uint64_t getCurrentRowNumber() const {return current;}
00486     virtual int dump(std::ostream& out, const char* del) const {
00487         if (current == 0) {
00488             out << tab.nrows << "\n";
00489             return 0;
00490         }
00491         else {
00492             return -1;
00493         }
00494     }
00495 
00496     virtual int getColumnAsByte(const char*, char&) const {return -1;}
00497     virtual int getColumnAsUByte(const char*, unsigned char&) const {
00498         return -1;}
00499     virtual int getColumnAsShort(const char*, int16_t&) const {return -1;}
00500     virtual int getColumnAsUShort(const char*, uint16_t&) const {return -1;}
00501     virtual int getColumnAsInt(const char*, int32_t&) const {return -1;}
00502     virtual int getColumnAsUInt(const char* cn, uint32_t&) const {
00503         return -1;}
00504     virtual int getColumnAsLong(const char* cn, int64_t& val) const {
00505         if (current == 0 && stricmp(tab.colName(), cn) == 0) {
00506             val = tab.nrows;
00507             return 1;}
00508         else {
00509             return -1;
00510         }
00511     }
00512     virtual int getColumnAsULong(const char* cn, uint64_t& val) const {
00513         if (current == 0 && stricmp(tab.colName(), cn) == 0) {
00514             val = tab.nrows;
00515             return 1;}
00516         else {
00517             return -1;
00518         }
00519     }
00520     virtual int getColumnAsFloat(const char*, float&) const {return -1;}
00521     virtual int getColumnAsDouble(const char*, double&) const {return -1;}
00522     virtual int getColumnAsString(const char*, std::string&) const {return -1;}
00523 
00524     virtual int getColumnAsByte(uint32_t, char&) const {return -1;}
00525     virtual int getColumnAsUByte(uint32_t, unsigned char&) const {return -1;}
00526     virtual int getColumnAsShort(uint32_t, int16_t&) const {return -1;}
00527     virtual int getColumnAsUShort(uint32_t, uint16_t&) const {return -1;}
00528     virtual int getColumnAsInt(uint32_t, int32_t&) const {return -1;}
00529     virtual int getColumnAsUInt(uint32_t cn, uint32_t&) const {
00530         return -1;}
00531     virtual int getColumnAsLong(uint32_t cn, int64_t& val) const {
00532         if (current == 0 && cn == 0) {
00533             val = tab.nrows;
00534             return 1;}
00535         else {
00536             return -1;
00537         }}
00538     virtual int getColumnAsULong(uint32_t cn, uint64_t& val) const {
00539         if (current == 0 && cn == 0) {
00540             val = tab.nrows;
00541             return 1;}
00542         else {
00543             return -1;
00544         }}
00545     virtual int getColumnAsFloat(uint32_t, float&) const {return -1;}
00546     virtual int getColumnAsDouble(uint32_t, double&) const {return -1;}
00547     virtual int getColumnAsString(uint32_t, std::string&) const {return -1;}
00548 
00549 private:
00550     const ibis::tabele& tab;
00551     int64_t current;
00552 
00553     cursor();
00554     cursor(const cursor&);
00555     cursor& operator=(const cursor&);
00556 }; // ibis::tabele::cursor
00557 
00558 inline ibis::table::cursor* ibis::tabele::createCursor() const {
00559     return new ibis::tabele::cursor(*this);
00560 } // ibis::tabele::createCursor
00561 #endif // IBIS_TAB_H

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