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

00001 // File: $Id$
00002 // Author: John Wu <John.Wu at acm.org>
00003 //      Lawrence Berkeley National Laboratory
00004 // Copyright 2007-2009 the Regents of the University of California
00005 #ifndef IBIS_MENSA_H
00006 #define IBIS_MENSA_H
00007 #include "table.h"      // ibis::table
00008 #include "util.h"       // ibis::partList
00009 #include "fileManager.h"// ibis::fileManager::storage
00010 
00018 namespace ibis {
00019     class mensa;
00020     class liga;
00021 } // namespace ibis
00022 
00030 class ibis::mensa : public ibis::table {
00031 public:
00032     mensa() : nrows(0) {};
00033     explicit mensa(const char* dir);
00034     mensa(const char* dir1, const char* dir2);
00035     virtual ~mensa() {clear();}
00036 
00037     virtual uint64_t nRows() const {return nrows;}
00038     virtual uint32_t nColumns() const {return naty.size();}
00039 
00040     virtual stringList columnNames() const;
00041     virtual typeList columnTypes() const;
00042     virtual int addPartition(const char* dir);
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;
00047     virtual int dump(std::ostream&, uint64_t, const char*) const;
00048 
00049     virtual int64_t getColumnAsBytes(const char*, char*) const;
00050     virtual int64_t getColumnAsUBytes(const char*, unsigned char*) const;
00051     virtual int64_t getColumnAsShorts(const char*, int16_t*) const;
00052     virtual int64_t getColumnAsUShorts(const char*, uint16_t*) const;
00053     virtual int64_t getColumnAsInts(const char*, int32_t*) const;
00054     virtual int64_t getColumnAsUInts(const char*, uint32_t*) const;
00055     virtual int64_t getColumnAsLongs(const char*, int64_t*) const;
00056     virtual int64_t getColumnAsULongs(const char*, uint64_t*) const;
00057     virtual int64_t getColumnAsFloats(const char*, float*) const;
00058     virtual int64_t getColumnAsDoubles(const char*, double*) const;
00059     virtual int64_t getColumnAsDoubles(const char*,
00060                                        std::vector<double>&) const;
00061     virtual int64_t getColumnAsStrings(const char*,
00062                                        std::vector<std::string>&) const;
00063 
00064     virtual long getHistogram(const char*, const char*,
00065                               double, double, double,
00066                               std::vector<uint32_t>&) const;
00067     virtual long getHistogram2D(const char*, const char*,
00068                                 double, double, double,
00069                                 const char*,
00070                                 double, double, double,
00071                                 std::vector<uint32_t>&) const;
00072     virtual long getHistogram3D(const char*, const char*,
00073                                 double, double, double,
00074                                 const char*,
00075                                 double, double, double,
00076                                 const char*,
00077                                 double, double, double,
00078                                 std::vector<uint32_t>&) const;
00079 
00080     virtual void estimate(const char* cond,
00081                           uint64_t& nmin, uint64_t& nmax) const;
00082     virtual void estimate(const ibis::qExpr* cond,
00083                           uint64_t& nmin, uint64_t& nmax) const;
00084     using table::select;
00085     virtual table* select(const char* sel, const char* cond) const;
00091     virtual table* select2(const char* sel, const char* cond,
00092                            const char* pts) const;
00093 
00094     virtual void orderby(const stringList&);
00095     virtual void orderby(const char *str) {ibis::table::orderby(str);}
00098     virtual void reverseRows() {};
00101     virtual table* groupby(const stringList&) const {return 0;}
00102     virtual table* groupby(const char *) const {return 0;}
00103 
00104     virtual int buildIndex(const char*, const char*);
00105     virtual int buildIndexes(const char*);
00106     virtual const char* indexSpec(const char*) const;
00107     virtual void indexSpec(const char*, const char*);
00108     virtual int getPartitions(std::vector<const ibis::part*> &) const;
00109 
00110     // Cursor class for row-wise data accesses.
00111     class cursor;
00113     virtual ibis::table::cursor* createCursor() const;
00114 
00115 protected:
00117     ibis::partList parts;
00119     ibis::table::namesTypes naty;
00120     uint64_t nrows;
00121 
00123     void clear();
00125     int64_t computeHits(const char* cond) const {
00126         return ibis::table::computeHits
00127             (reinterpret_cast<const std::vector<const ibis::part*>&>(parts),
00128              cond);}
00129 
00130 private:
00131     // disallow copying.
00132     mensa(const mensa&);
00133     mensa& operator=(const mensa&);
00134 
00135     friend class cursor;
00136 }; // ibis::mensa
00137 
00138 class ibis::mensa::cursor : public ibis::table::cursor {
00139 public:
00140     cursor(const ibis::mensa& t);
00141     virtual ~cursor() {clearBuffers();};
00142 
00143     virtual uint64_t nRows() const {return tab.nRows();}
00144     virtual uint32_t nColumns() const {return tab.nColumns();}
00145     virtual ibis::table::stringList columnNames() const {
00146         return tab.columnNames();}
00147     virtual ibis::table::typeList columnTypes() const {
00148         return tab.columnTypes();}
00149     virtual int fetch();
00150     virtual int fetch(uint64_t);
00151     virtual int fetch(ibis::table::row&);
00152     virtual int fetch(uint64_t, ibis::table::row&);
00153     virtual uint64_t getCurrentRowNumber() const {return curRow;}
00154     virtual int dump(std::ostream& out, const char* del) const;
00155 
00156     int dumpBlock(std::ostream& out, const char* del);
00157     int dumpSome(std::ostream& out, uint64_t nr, const char* del);
00158 
00159     virtual int getColumnAsByte(const char*, char&) const;
00160     virtual int getColumnAsUByte(const char*, unsigned char&) const;
00161     virtual int getColumnAsShort(const char*, int16_t&) const;
00162     virtual int getColumnAsUShort(const char*, uint16_t&) const;
00163     virtual int getColumnAsInt(const char*, int32_t&) const;
00164     virtual int getColumnAsUInt(const char*, uint32_t&) const;
00165     virtual int getColumnAsLong(const char*, int64_t&) const;
00166     virtual int getColumnAsULong(const char*, uint64_t&) const;
00167     virtual int getColumnAsFloat(const char*, float&) const;
00168     virtual int getColumnAsDouble(const char*, double&) const;
00169     virtual int getColumnAsString(const char*, std::string&) const;
00170 
00171     virtual int getColumnAsByte(uint32_t, char&) const;
00172     virtual int getColumnAsUByte(uint32_t, unsigned char&) const;
00173     virtual int getColumnAsShort(uint32_t, int16_t&) const;
00174     virtual int getColumnAsUShort(uint32_t, uint16_t&) const;
00175     virtual int getColumnAsInt(uint32_t, int32_t&) const;
00176     virtual int getColumnAsUInt(uint32_t, uint32_t&) const;
00177     virtual int getColumnAsLong(uint32_t, int64_t&) const;
00178     virtual int getColumnAsULong(uint32_t, uint64_t&) const;
00179     virtual int getColumnAsFloat(uint32_t, float&) const;
00180     virtual int getColumnAsDouble(uint32_t, double&) const;
00181     virtual int getColumnAsString(uint32_t, std::string&) const;
00182 
00183 protected:
00189     struct bufferElement {
00190         const char* cname; 
00191         ibis::TYPE_T ctype; 
00192         mutable void* cval; 
00193 
00194         bufferElement() : cname(0), ctype(ibis::UNKNOWN_TYPE), cval(0) {}
00195         ~bufferElement();
00196     }; // bufferElement
00197     typedef std::map<const char*, uint32_t, ibis::lessi> bufferMap;
00198     std::vector<bufferElement> buffer;
00199     bufferMap bufmap;
00200     const ibis::mensa& tab;
00201     unsigned curPart;
00202     unsigned preferred_block_size;
00203     uint64_t pBegin; 
00204     uint64_t bBegin; 
00205     uint64_t bEnd;   
00206     int64_t  curRow; 
00207 
00208     void clearBuffers();
00209     int  fillBuffers() const;
00210     int  fillBuffer(uint32_t) const;
00211     void fillRow(ibis::table::row& res) const;
00212     int  dumpIJ(std::ostream&, uint32_t, uint32_t) const;
00213 
00214 private:
00215     cursor();
00216     cursor(const cursor&);
00217     cursor& operator=(const cursor&);
00218 }; // ibis::mensa::cursor
00219 
00227 class ibis::liga : public ibis::mensa {
00228 public:
00229     liga(ibis::part&);
00230     liga(const ibis::partList&);
00231     ~liga();
00232 
00235     virtual int addPartition(const char*) {return -1;}
00236 
00237 private:
00238     liga();
00239     liga(const liga&);
00240     liga& operator=(const liga&);
00241 }; // ibis::liga
00242 
00243 namespace ibis {
00244     namespace util {
00247         template <typename T> static void 
00248         addIncoreData(void*& to, const array_t<T>& from,
00249                       uint32_t nold, const T special);
00250         void
00251         addStrings(void*&, const std::vector<std::string>&, uint32_t);
00252     }
00253 }
00254 
00255 inline int
00256 ibis::mensa::cursor::getColumnAsByte(const char* cn, char& val) const {
00257     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00258         return -1;
00259     bufferMap::const_iterator it = bufmap.find(cn);
00260     if (it != bufmap.end())
00261         return getColumnAsByte((*it).second, val);
00262     else
00263         return -2;
00264 } // ibis::mensa::cursor::getColumnAsByte
00265 
00266 inline int
00267 ibis::mensa::cursor::getColumnAsUByte(const char* cn,
00268                                       unsigned char& val) const {
00269     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00270         return -1;
00271     bufferMap::const_iterator it = bufmap.find(cn);
00272     if (it != bufmap.end())
00273         return getColumnAsUByte((*it).second, val);
00274     else
00275         return -2;
00276 } // ibis::mensa::cursor::getColumnAsUByte
00277 
00278 inline int
00279 ibis::mensa::cursor::getColumnAsShort(const char* cn, int16_t& val) const {
00280     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00281         return -1;
00282     bufferMap::const_iterator it = bufmap.find(cn);
00283     if (it != bufmap.end())
00284         return getColumnAsShort((*it).second, val);
00285     else
00286         return -2;
00287 } // ibis::mensa::cursor::getColumnAsShort
00288 
00289 inline int
00290 ibis::mensa::cursor::getColumnAsUShort(const char* cn, uint16_t& val) const {
00291     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00292         return -1;
00293     bufferMap::const_iterator it = bufmap.find(cn);
00294     if (it != bufmap.end())
00295         return getColumnAsUShort((*it).second, val);
00296     else
00297         return -2;
00298 } // ibis::mensa::cursor::getColumnAsUShort
00299 
00300 inline int
00301 ibis::mensa::cursor::getColumnAsInt(const char* cn, int32_t& val) const {
00302     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00303         return -1;
00304     bufferMap::const_iterator it = bufmap.find(cn);
00305     if (it != bufmap.end())
00306         return getColumnAsInt((*it).second, val);
00307     else
00308         return -2;
00309 } // ibis::mensa::cursor::getColumnAsInt
00310 
00311 inline int
00312 ibis::mensa::cursor::getColumnAsUInt(const char* cn, uint32_t& val) const {
00313     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00314         return -1;
00315     bufferMap::const_iterator it = bufmap.find(cn);
00316     if (it != bufmap.end())
00317         return getColumnAsUInt((*it).second, val);
00318     else
00319         return -2;
00320 } // ibis::mensa::cursor::getColumnAsUInt
00321 
00322 inline int
00323 ibis::mensa::cursor::getColumnAsLong(const char* cn, int64_t& val) const {
00324     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00325         return -1;
00326     bufferMap::const_iterator it = bufmap.find(cn);
00327     if (it != bufmap.end())
00328         return getColumnAsLong((*it).second, val);
00329     else
00330         return -2;
00331 } // ibis::mensa::cursor::getColumnAsLong
00332 
00333 inline int
00334 ibis::mensa::cursor::getColumnAsULong(const char* cn, uint64_t& val) const {
00335     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00336         return -1;
00337     bufferMap::const_iterator it = bufmap.find(cn);
00338     if (it != bufmap.end())
00339         return getColumnAsULong((*it).second, val);
00340     else
00341         return -2;
00342 } // ibis::mensa::cursor::getColumnAsULong
00343 
00344 inline int
00345 ibis::mensa::cursor::getColumnAsFloat(const char* cn, float& val) const {
00346     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00347         return -1;
00348     bufferMap::const_iterator it = bufmap.find(cn);
00349     if (it != bufmap.end())
00350         return getColumnAsFloat((*it).second, val);
00351     else
00352         return -2;
00353 } // ibis::mensa::cursor::getColumnAsFloat
00354 
00355 inline int
00356 ibis::mensa::cursor::getColumnAsDouble(const char* cn, double& val) const {
00357     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00358         return -1;
00359     bufferMap::const_iterator it = bufmap.find(cn);
00360     if (it != bufmap.end())
00361         return getColumnAsDouble((*it).second, val);
00362     else
00363         return -2;
00364 } // ibis::mensa::cursor::getColumnAsDouble
00365 
00366 inline int
00367 ibis::mensa::cursor::getColumnAsString(const char* cn,
00368                                        std::string& val) const {
00369     if (curRow < 0 || curPart >= tab.parts.size() || cn == 0 || *cn == 0)
00370         return -1;
00371     bufferMap::const_iterator it = bufmap.find(cn);
00372     if (it != bufmap.end())
00373         return getColumnAsString((*it).second, val);
00374     else
00375         return -2;
00376 } // ibis::mensa::cursor::getColumnAsString
00377 
00378 inline int
00379 ibis::mensa::dump(std::ostream& out, uint64_t nr, const char* del) const {
00380     if (parts.empty()) return 0;
00381     ibis::mensa::cursor cur(*this);
00382     int ierr = cur.dumpSome(out, nr, del);
00383     return ierr;
00384 } // ibis::mensa::dump
00385 #endif // IBIS_MENSA_H


	Contact us Disclaimers FastBit source code FastBit mailing list archive