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

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