FastBit: table.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_TABLE_H
00005 #define IBIS_TABLE_H
00006 
00016 #include <iostream>     // std::ostream
00017 #include <vector>       // std::vector
00018 #include <map>          // std::map
00019 #include <string>       // std::string
00020 #include "const.h"      // intxx_t, uintxx_t, ... from stdint.h
00021 
00022 namespace ibis {
00023 
00025     enum TYPE_T {
00027         UNKNOWN_TYPE=0,
00029         OID,
00030         BYTE,   
00031         UBYTE,  
00032         SHORT,  
00033         USHORT, 
00034         INT,    
00035         UINT,   
00036         LONG,   
00037         ULONG,  
00038         FLOAT,  
00039         DOUBLE, 
00040 
00041 
00042         CATEGORY,
00046         TEXT,
00051         BLOB
00052     };
00054     FASTBIT_CXX_DLLSPEC extern const char** TYPESTRING;
00056     FASTBIT_CXX_DLLSPEC extern const char* TYPECODE;
00057 
00058     class table;
00059     class tablex;
00060     class tableList;
00061 } // namespace ibis
00062 
00073 class FASTBIT_CXX_DLLSPEC ibis::table {
00074 public:
00078     static ibis::table* create(ibis::part&);
00082     static ibis::table* create(const ibis::partList&);
00086     static ibis::table* create(const char* dir);
00092     static ibis::table* create(const char* dir1, const char* dir2);
00093 
00095     virtual ~table() {};
00096 
00099     virtual const char* name() const {return name_.c_str();}
00101     virtual const char* description() const {return desc_.c_str();}
00103     virtual uint64_t nRows() const =0;
00105     virtual uint32_t nColumns() const =0;
00106 
00110     typedef std::vector<const char*> stringList;
00112     typedef std::vector<ibis::TYPE_T> typeList;
00114     typedef std::map<const char*, ibis::TYPE_T, ibis::lessi> namesTypes;
00115 
00116     virtual stringList columnNames() const =0; 
00117     virtual typeList columnTypes() const =0; 
00118 
00120     virtual void describe(std::ostream&) const =0;
00122     virtual void dumpNames(std::ostream& out, const char* del=", ") const =0;
00126     virtual int dump(std::ostream& out, const char* del=", ") const =0;
00128     virtual int dump(std::ostream& out, uint64_t nr,
00129                      const char* del=", ") const =0;
00132     virtual void estimate(const char* cond,
00133                           uint64_t& nmin, uint64_t& nmax) const =0;
00136     virtual void estimate(const ibis::qExpr* cond,
00137                           uint64_t& nmin, uint64_t& nmax) const =0;
00140     virtual table* select(const char* sel, const char* cond) const =0;
00143     virtual table* select(const char* sel, const ibis::qExpr* cond) const;
00144 
00146     static table* select(const std::vector<const ibis::part*>& parts,
00147                          const char* sel, const char* cond);
00149     static table* select(const std::vector<const ibis::part*>& parts,
00150                          const char* sel, const ibis::qExpr* cond);
00152     static int64_t computeHits(const std::vector<const ibis::part*>& parts,
00153                                const char* cond);
00155     static int64_t computeHits(const std::vector<const ibis::part*>& parts,
00156                                const ibis::qExpr* cond);
00157 
00164     virtual table* groupby(const stringList&) const =0;
00167     virtual table* groupby(const char*) const;
00175     virtual void orderby(const stringList&)=0;
00177     virtual void orderby(const char*);
00179     virtual void reverseRows()=0;
00180 
00193     virtual int addPartition(const char* dir) {return -1;}
00195     virtual int getPartitions(std::vector<const ibis::part*>&) const {
00196         return -1;}
00197 
00212     virtual int buildIndex(const char* colname, const char* option=0) =0;
00217     virtual int buildIndexes(const char* options=0) =0;
00220     virtual const char* indexSpec(const char* colname=0) const =0;
00223     virtual void indexSpec(const char* opt, const char* colname=0) =0;
00225 
00233     virtual int64_t getColumnAsBytes(const char* cname, char* vals) const =0;
00234     virtual int64_t getColumnAsUBytes(const char* cname,
00235                                       unsigned char* vals) const =0;
00236     virtual int64_t getColumnAsShorts(const char* cname,
00237                                       int16_t* vals) const =0;
00238     virtual int64_t getColumnAsUShorts(const char* cname,
00239                                        uint16_t* vals) const =0;
00240     virtual int64_t getColumnAsInts(const char* cname,
00241                                     int32_t* vals) const =0;
00242     virtual int64_t getColumnAsUInts(const char* cname,
00243                                      uint32_t* vals) const =0;
00244     virtual int64_t getColumnAsLongs(const char* cname,
00245                                      int64_t* vals) const =0;
00246     virtual int64_t getColumnAsULongs(const char* cname,
00247                                       uint64_t* vals) const =0;
00248     virtual int64_t getColumnAsFloats(const char* cname,
00249                                       float* vals) const =0;
00250     virtual int64_t getColumnAsDoubles(const char* cname,
00251                                        double* vals) const =0;
00252     virtual int64_t getColumnAsDoubles(const char* cname,
00253                                        std::vector<double>& vals) const =0;
00257     virtual int64_t getColumnAsStrings(const char* cname,
00258                                        std::vector<std::string>& vals) const =0;
00260 
00274     virtual long getHistogram(const char* constraints,
00275                               const char* cname,
00276                               double begin, double end, double stride,
00277                               std::vector<uint32_t>& counts) const =0;
00284     virtual long getHistogram2D(const char* constraints,
00285                                 const char* cname1,
00286                                 double begin1, double end1, double stride1,
00287                                 const char* cname2,
00288                                 double begin2, double end2, double stride2,
00289                                 std::vector<uint32_t>& counts) const =0;
00296     virtual long getHistogram3D(const char* constraints,
00297                                 const char* cname1,
00298                                 double begin1, double end1, double stride1,
00299                                 const char* cname2,
00300                                 double begin2, double end2, double stride2,
00301                                 const char* cname3,
00302                                 double begin3, double end3, double stride3,
00303                                 std::vector<uint32_t>& counts) const =0;
00305 
00307     struct row {
00308         std::vector<std::string>   bytesnames; 
00309         std::vector<signed char>   bytesvalues;
00310         std::vector<std::string>   ubytesnames; 
00311         std::vector<unsigned char> ubytesvalues;
00312         std::vector<std::string>   shortsnames; 
00313         std::vector<int16_t>       shortsvalues;
00314         std::vector<std::string>   ushortsnames; 
00315         std::vector<uint16_t>      ushortsvalues;
00316         std::vector<std::string>   intsnames; 
00317         std::vector<int32_t>       intsvalues;
00318         std::vector<std::string>   uintsnames; 
00319         std::vector<uint32_t>      uintsvalues;
00320         std::vector<std::string>   longsnames; 
00321         std::vector<int64_t>       longsvalues;
00322         std::vector<std::string>   ulongsnames; 
00323         std::vector<uint64_t>      ulongsvalues;
00324         std::vector<std::string>   floatsnames; 
00325         std::vector<float>         floatsvalues;
00326         std::vector<std::string>   doublesnames; 
00327         std::vector<double>        doublesvalues;
00328         std::vector<std::string>   catsnames; 
00329         std::vector<std::string>   catsvalues;
00330         std::vector<std::string>   textsnames; 
00331         std::vector<std::string>   textsvalues;
00332         std::vector<std::string>   blobsnames; 
00333         std::vector<std::string>   blobsvalues;
00334 
00336         void clear();
00338         void clearValues();
00340         uint32_t nColumns() const {
00341             return bytesvalues.size() + ubytesvalues.size() +
00342                 shortsvalues.size() + ushortsvalues.size() +
00343                 intsvalues.size() + uintsvalues.size() +
00344                 longsvalues.size() + ulongsvalues.size() +
00345                 floatsvalues.size() + doublesvalues.size() +
00346                 catsvalues.size() + textsvalues.size() + blobsvalues.size();}
00347     }; // struct row
00348 
00349     // Cursor class for row-wise data accesses.
00350     class cursor;
00352     virtual cursor* createCursor() const =0;
00353 
00356     static void parseNames(char* in, stringList& out);
00357 
00358 protected:
00359 
00360     std::string name_;  
00361     std::string desc_;  
00362 
00364     table() {};
00366     table(const char* na, const char* de) : name_(na), desc_(de) {};
00367 
00368 private:
00369     // re-enforce the prohibitions on copying and assignment.
00370     table(const table&);
00371     table& operator=(const table&);
00372 }; // class ibis::table
00373 
00386 class FASTBIT_CXX_DLLSPEC ibis::tablex {
00387 public:
00389     static ibis::tablex* create();
00390 //     /// Make the incoming table expandable.  Not yet implemented
00391 //     static ibis::tablex* makeExtensible(ibis::table* t);
00392 
00393     virtual ~tablex() {}; // nothing to do.
00394 
00396     virtual int addColumn(const char* cname, ibis::TYPE_T ctype,
00397                           const char* cdesc=0, const char* idx=0) =0;
00398 
00419     virtual int append(const char* cname, uint64_t begin, uint64_t end,
00420                        void* values) =0;
00421 
00449     virtual int appendRow(const ibis::table::row&) =0;
00455     virtual int appendRow(const char* line, const char* delimiters=0) = 0;
00463     virtual int appendRows(const std::vector<ibis::table::row>&) =0;
00464 
00487     virtual int readCSV(const char* inputfile, int maxrows=0,
00488                         const char* outputdir=0, const char* delimiters=0) =0;
00502     virtual int readSQLDump(const char* inputfile, std::string& tname,
00503                             int maxrows=0, const char* outputdir=0) =0;
00504 
00506     virtual int readNamesAndTypes(const char* filename);
00508     virtual int parseNamesAndTypes(const char* txt);
00509 
00523     virtual int write(const char* dir, const char* tname=0,
00524                       const char* tdesc=0, const char* idx=0) const =0;
00532     virtual int writeMetaData(const char* dir, const char* tname=0,
00533                               const char* tdesc=0, const char* idx=0) const =0;
00534 
00538     virtual void clearData() =0;
00550     virtual int32_t reserveSpace(uint32_t) {return 0;}
00560     virtual uint32_t capacity() const {return 0;}
00561 
00563     virtual uint32_t mRows() const =0;
00565     virtual uint32_t mColumns() const =0;
00567     virtual void describe(std::ostream&) const =0;
00568 
00569 protected:
00570     tablex() {}; // Derived classes need this.
00571 
00572 private:
00573     tablex(const tablex&); // no copying
00574     tablex& operator=(const tablex&); // no assignment
00575 }; // class ibis::tablex
00576 
00580 class FASTBIT_CXX_DLLSPEC ibis::tableList {
00581 public:
00582     typedef std::map< const char*, ibis::table*, ibis::lessi > tableSet;
00583     typedef tableSet::const_iterator iterator;
00584 
00587     bool empty() const {return tables.empty();}
00589     uint32_t size() const {return tables.size();}
00591     iterator begin() const {return tables.begin();}
00595     iterator end() const {return tables.end();}
00596 
00599     const ibis::table* operator[](const char* tname) const {
00600         tableSet::const_iterator it = tables.find(tname);
00601         if (it != tables.end())
00602             return (*it).second;
00603         else
00604             return 0;
00605     }
00606 
00612     void add(ibis::table*& tb) {
00613         tableSet::iterator it = tables.find(tb->name());
00614         if (it == tables.end()) {
00615             tables[tb->name()] = tb;
00616             tb=0;
00617         }
00618         else {
00619             ibis::table* tmp = (*it).second;
00620             tables[tb->name()] = tb;
00621             tb = tmp;
00622         }
00623     }
00624 
00628     void remove(const char* tname) {
00629         tableSet::iterator it = tables.find(tname);
00630         if (it != tables.end()) {
00631             ibis::table* tmp = (*it).second;
00632             tables.erase(it);
00633             delete tmp;
00634         }
00635     }
00636 
00638     tableList() {};
00639 
00641     ~tableList() {
00642         while (! tables.empty()) {
00643             tableSet::iterator it = tables.begin();
00644             ibis::table* tmp = (*it).second;
00645             tables.erase(it);
00646             delete tmp;
00647         }
00648     }
00649 
00650 private:
00652     tableSet tables;
00653 
00654     // Can not copy or assign.
00655     tableList(const tableList&);
00656     tableList& operator=(const tableList&);
00657 }; // ibis::tableList
00658 
00664 class FASTBIT_CXX_DLLSPEC ibis::table::cursor {
00665 public:
00666     virtual ~cursor() {};
00667     virtual uint64_t nRows() const =0;
00668     virtual uint32_t nColumns() const =0;
00669     virtual ibis::table::stringList columnNames() const =0;
00670     virtual ibis::table::typeList columnTypes() const =0;
00673     virtual int fetch() =0;
00677     virtual int fetch(uint64_t rownum) =0;
00682     virtual uint64_t getCurrentRowNumber() const =0;
00683 
00686     virtual int fetch(ibis::table::row&) =0;
00689     virtual int fetch(uint64_t rownum, ibis::table::row&) =0;
00690 
00692     virtual int dump(std::ostream& out, const char* del=", ") const =0;
00693 
00697     virtual int getColumnAsByte(const char* cname, char&) const =0;
00698     virtual int getColumnAsUByte(const char* cname, unsigned char&) const =0;
00699     virtual int getColumnAsShort(const char* cname, int16_t&) const =0;
00700     virtual int getColumnAsUShort(const char* cname, uint16_t&) const =0;
00701     virtual int getColumnAsInt(const char* cname, int32_t&) const =0;
00702     virtual int getColumnAsUInt(const char* cname, uint32_t&) const =0;
00703     virtual int getColumnAsLong(const char* cname, int64_t&) const =0;
00704     virtual int getColumnAsULong(const char* cname, uint64_t&) const =0;
00705     virtual int getColumnAsFloat(const char* cname, float&) const =0;
00706     virtual int getColumnAsDouble(const char* cname, double&) const =0;
00707     virtual int getColumnAsString(const char* cname, std::string&) const =0;
00708 
00714     virtual int getColumnAsByte(uint32_t cnum, char& val) const =0;
00715     virtual int getColumnAsUByte(uint32_t cnum, unsigned char& val) const =0;
00716     virtual int getColumnAsShort(uint32_t cnum, int16_t& val) const =0;
00717     virtual int getColumnAsUShort(uint32_t cnum, uint16_t& val) const =0;
00718     virtual int getColumnAsInt(uint32_t cnum, int32_t& val) const =0;
00719     virtual int getColumnAsUInt(uint32_t cnum, uint32_t& val) const =0;
00720     virtual int getColumnAsLong(uint32_t cnum, int64_t& val) const =0;
00721     virtual int getColumnAsULong(uint32_t cnum, uint64_t& val) const =0;
00722     virtual int getColumnAsFloat(uint32_t cnum, float& val) const =0;
00723     virtual int getColumnAsDouble(uint32_t cnum, double& val) const =0;
00724     virtual int getColumnAsString(uint32_t cnum, std::string& val) const =0;
00725 
00726 protected:
00727     cursor() {};
00728     cursor(const cursor&); // not implemented
00729     cursor& operator=(const cursor&) ; // not implemented
00730 }; // ibis::table::cursor
00731 
00732 inline void ibis::table::row::clear() {
00733     bytesnames.clear();
00734     bytesvalues.clear();
00735     ubytesnames.clear();
00736     ubytesvalues.clear();
00737     shortsnames.clear();
00738     shortsvalues.clear();
00739     ushortsnames.clear();
00740     ushortsvalues.clear();
00741     intsnames.clear();
00742     intsvalues.clear();
00743     uintsnames.clear();
00744     uintsvalues.clear();
00745     longsnames.clear();
00746     longsvalues.clear();
00747     ulongsnames.clear();
00748     ulongsvalues.clear();
00749     floatsnames.clear();
00750     floatsvalues.clear();
00751     doublesnames.clear();
00752     doublesvalues.clear();
00753     catsnames.clear();
00754     catsvalues.clear();
00755     textsnames.clear();
00756     textsvalues.clear();
00757     blobsnames.clear();
00758     blobsvalues.clear();
00759 } // ibis::table::row::clear
00760 
00761 inline void ibis::table::row::clearValues() {
00762     bytesvalues.clear();
00763     ubytesvalues.clear();
00764     shortsvalues.clear();
00765     ushortsvalues.clear();
00766     intsvalues.clear();
00767     uintsvalues.clear();
00768     longsvalues.clear();
00769     ulongsvalues.clear();
00770     floatsvalues.clear();
00771     doublesvalues.clear();
00772     catsvalues.clear();
00773     textsvalues.clear();
00774     blobsvalues.clear();
00775 } // ibis::table::row::clearValues
00776 #endif // IBIS_TABLE_H


	Contact us Disclaimers FastBit source code FastBit mailing list archive