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

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


	Contact us Disclaimers FastBit source code FastBit mailing list archive