table.h

Go to the documentation of this file.

// File: $Id$
// Author: John Wu <John.Wu at ACM.org>
// Copyright 2007-2008 the Regents of the University of California
#ifndef IBIS_TABLE_H
#define IBIS_TABLE_H

#include <ostream>      // std::ostream
#include <vector>       // std::vector
#include <map>          // std::map
#include <string>       // std::string
#include <cstdlib>      // size_t
#include "const.h"      // intxx_t, uintxx_t, ... from stdint.h

namespace ibis {

    enum TYPE_T {UNKNOWN_TYPE=0,

                 OID,   

                 BYTE,  
                 UBYTE, 
                 SHORT, 
                 USHORT,
                 INT,   
                 UINT,  
                 LONG,  
                 ULONG, 
                 FLOAT, 
                 DOUBLE,
                 CATEGORY,      
                 TEXT   
    };
    FASTBIT_CXX_DLLSPEC extern const char** TYPESTRING;
    FASTBIT_CXX_DLLSPEC extern const char* TYPECODE;

    // forward declarations
    class table;
    class tablex;
    class tableList;
} // namespace ibis

class FASTBIT_CXX_DLLSPEC ibis::table {
public:
    static ibis::table* create(const char* dir);
    static ibis::table* create(const char* dir1, const char* dir2);

    virtual ~table() {};

    virtual const char* name() const {return name_.c_str();}
    virtual const char* description() const {return desc_.c_str();}
    virtual uint64_t nRows() const=0;
    virtual size_t nColumns() const=0;

    typedef std::vector<const char*> stringList;
    typedef std::vector<ibis::TYPE_T> typeList;
    typedef std::map<const char*, ibis::TYPE_T, ibis::lessi> namesTypes;

    virtual stringList columnNames() const=0; 
    virtual typeList columnTypes() const=0; 

    virtual void describe(std::ostream&) const=0;
    virtual int dump(std::ostream& out, const char* del=", ") const=0;

    virtual void estimate(const char* cond,
                          uint64_t& nmin, uint64_t& nmax) const=0;
    virtual table* select(const char* sel, const char* cond) const=0;

    virtual table* groupby(const stringList&) const=0;
    virtual table* groupby(const char*) const;
    virtual void orderby(const stringList&)=0;
    virtual void orderby(const char*);
    virtual void reverseRows()=0;

    virtual int addPartition(const char* dir) {return -1;}


    virtual int buildIndex(const char* colname, const char* option=0) =0;
    virtual int buildIndexes(const char* options=0) =0;
    virtual const char* indexSpec(const char* colname=0) const=0;
    virtual void indexSpec(const char* opt, const char* colname=0) =0;

    virtual int64_t getColumnAsBytes(const char* cname, char* vals) const=0;
    virtual int64_t getColumnAsUBytes(const char* cname,
                                      unsigned char* vals) const=0;
    virtual int64_t getColumnAsShorts(const char* cname,
                                      int16_t* vals) const=0;
    virtual int64_t getColumnAsUShorts(const char* cname,
                                       uint16_t* vals) const=0;
    virtual int64_t getColumnAsInts(const char* cname,
                                    int32_t* vals) const=0;
    virtual int64_t getColumnAsUInts(const char* cname,
                                     uint32_t* vals) const=0;
    virtual int64_t getColumnAsLongs(const char* cname,
                                     int64_t* vals) const=0;
    virtual int64_t getColumnAsULongs(const char* cname,
                                      uint64_t* vals) const=0;
    virtual int64_t getColumnAsFloats(const char* cname,
                                      float* vals) const=0;
    virtual int64_t getColumnAsDoubles(const char* cname,
                                       double* vals) const=0;
    virtual int64_t getColumnAsStrings(const char* cname,
                                       std::vector<std::string>& vals) const=0;

    virtual long getHistogram(const char* constraints,
                              const char* cname,
                              double begin, double end, double stride,
                              std::vector<size_t>& counts) const=0;
    virtual long getHistogram2D(const char* constraints,
                                const char* cname1,
                                double begin1, double end1, double stride1,
                                const char* cname2,
                                double begin2, double end2, double stride2,
                                std::vector<size_t>& counts) const=0;
    virtual long getHistogram3D(const char* constraints,
                                const char* cname1,
                                double begin1, double end1, double stride1,
                                const char* cname2,
                                double begin2, double end2, double stride2,
                                const char* cname3,
                                double begin3, double end3, double stride3,
                                std::vector<size_t>& counts) const=0;

    struct row {
        std::vector<std::string>   bytesnames; 
        std::vector<signed char>   bytesvalues;
        std::vector<std::string>   ubytesnames; 
        std::vector<unsigned char> ubytesvalues;
        std::vector<std::string>   shortsnames; 
        std::vector<int16_t>       shortsvalues;
        std::vector<std::string>   ushortsnames; 
        std::vector<uint16_t>      ushortsvalues;
        std::vector<std::string>   intsnames; 
        std::vector<int32_t>       intsvalues;
        std::vector<std::string>   uintsnames; 
        std::vector<uint32_t>      uintsvalues;
        std::vector<std::string>   longsnames; 
        std::vector<int64_t>       longsvalues;
        std::vector<std::string>   ulongsnames; 
        std::vector<uint64_t>      ulongsvalues;
        std::vector<std::string>   floatsnames; 
        std::vector<float>         floatsvalues;
        std::vector<std::string>   doublesnames; 
        std::vector<double>        doublesvalues;
        std::vector<std::string>   catsnames; 
        std::vector<std::string>   catsvalues;
        std::vector<std::string>   textsnames; 
        std::vector<std::string>   textsvalues;

        void clear();
        void clearValues();
    }; // struct row

    // Cursor class for row-wise data accesses.
    class cursor;
    virtual cursor* createCursor() const=0;

protected:

    std::string name_;  
    std::string desc_;  

    table() {};
    table(const char* na, const char* de) : name_(na), desc_(de) {};
    void parseNames(char* in, stringList& out) const;

private:
    // re-enforce the prohibitions on copying and assignment.
    table(const table&);
    const table& operator=(const table&);
}; // class ibis::table

class FASTBIT_CXX_DLLSPEC ibis::tablex {
public:
    static ibis::tablex* create();
    static ibis::tablex* makeExtensible(ibis::table* t);

    virtual ~tablex() {}; // nothing to do.

    virtual int addColumn(const char* cname, ibis::TYPE_T ctype) =0;
    virtual int addColumn(const char* cname, ibis::TYPE_T ctype,
                          const char* cdesc) =0;
    virtual int append(const char* cname, uint64_t begin, uint64_t end,
                       void* values) =0;

    virtual int appendRow(const ibis::table::row&) =0;
    virtual int appendRow(const char* line, const char* delimiters=0) = 0;
    virtual int appendRows(const std::vector<ibis::table::row>&) =0;

    virtual int readCSV(const char* filename, const char* delimiters=0) =0;

    virtual int write(const char* dir, const char* tname,
                      const char* tdesc) const =0;

    virtual void clearData() =0;

protected:
    tablex() {}; // Derived classes need this.

private:
    tablex(const tablex&); // no copying
    const tablex& operator=(const tablex&); // no assignment
}; // class ibis::tablex

class FASTBIT_CXX_DLLSPEC ibis::tableList {
public:
    typedef std::map< const char*, ibis::table*, ibis::lessi > tableSet;
    typedef tableSet::const_iterator iterator;

    bool empty() const {return tables.empty();}
    size_t size() const {return tables.size();}
    iterator begin() const {return tables.begin();}
    iterator end() const {return tables.end();}

    const ibis::table* operator[](const char* tname) const {
        tableSet::const_iterator it = tables.find(tname);
        if (it != tables.end())
            return (*it).second;
        else
            return 0;
    }

    void add(ibis::table*& tb) {
        tableSet::iterator it = tables.find(tb->name());
        if (it == tables.end()) {
            tables[tb->name()] = tb;
            tb=0;
        }
        else {
            ibis::table* tmp = (*it).second;
            tables[tb->name()] = tb;
            tb = tmp;
        }
    }

    void remove(const char* tname) {
        tableSet::iterator it = tables.find(tname);
        if (it != tables.end()) {
            ibis::table* tmp = (*it).second;
            tables.erase(it);
            delete tmp;
        }
    }

    tableList() {};

    ~tableList() {
        while (! tables.empty()) {
            tableSet::iterator it = tables.begin();
            ibis::table* tmp = (*it).second;
            tables.erase(it);
            delete tmp;
        }
    }

private:
    tableSet tables;

    // Can not copy or assign.
    tableList(const tableList&);
    const tableList& operator=(const tableList&);
}; // ibis::tableList

class FASTBIT_CXX_DLLSPEC ibis::table::cursor {
public:
    virtual ~cursor() {};
    virtual uint64_t nRows() const=0;
    virtual size_t nColumns() const=0;
    virtual ibis::table::stringList columnNames() const=0;
    virtual ibis::table::typeList columnTypes() const=0;
    virtual int fetch() =0;
    virtual int fetch(uint64_t rownum) =0;
    virtual uint64_t getCurrentRowNumber() const=0;

    virtual int fetch(ibis::table::row&) =0;
    virtual int fetch(uint64_t rownum, ibis::table::row&) =0;

    virtual int dump(std::ostream& out, const char* del=", ") const=0;

    virtual int getColumnAsByte(const char* cname, char*) const=0;
    virtual int getColumnAsUByte(const char* cname, unsigned char*) const=0;
    virtual int getColumnAsShort(const char* cname, int16_t*) const=0;
    virtual int getColumnAsUShort(const char* cname, uint16_t*) const=0;
    virtual int getColumnAsInt(const char* cname, int32_t*) const=0;
    virtual int getColumnAsUInt(const char* cname, uint32_t*) const=0;
    virtual int getColumnAsLong(const char* cname, int64_t*) const=0;
    virtual int getColumnAsULong(const char* cname, uint64_t*) const=0;
    virtual int getColumnAsFloat(const char* cname, float*) const=0;
    virtual int getColumnAsDouble(const char* cname, double*) const=0;
    virtual int getColumnAsString(const char* cname, std::string&) const=0;

    virtual int getColumnAsByte(size_t cnum, char* val) const=0;
    virtual int getColumnAsUByte(size_t cnum, unsigned char* val) const=0;
    virtual int getColumnAsShort(size_t cnum, int16_t* val) const=0;
    virtual int getColumnAsUShort(size_t cnum, uint16_t* val) const=0;
    virtual int getColumnAsInt(size_t cnum, int32_t* val) const=0;
    virtual int getColumnAsUInt(size_t cnum, uint32_t* val) const=0;
    virtual int getColumnAsLong(size_t cnum, int64_t* val) const=0;
    virtual int getColumnAsULong(size_t cnum, uint64_t* val) const=0;
    virtual int getColumnAsFloat(size_t cnum, float* val) const=0;
    virtual int getColumnAsDouble(size_t cnum, double* val) const=0;
    virtual int getColumnAsString(size_t cnum, std::string& val) const=0;

protected:
    cursor() {};
    cursor(const cursor&); // not implemented
    cursor& operator=(const cursor&) ; // not implemented
}; // ibis::table::cursor

inline void ibis::table::row::clear() {
    bytesnames.clear();
    bytesvalues.clear();
    ubytesnames.clear();
    ubytesvalues.clear();
    shortsnames.clear();
    shortsvalues.clear();
    ushortsnames.clear();
    ushortsvalues.clear();
    intsnames.clear();
    intsvalues.clear();
    uintsnames.clear();
    uintsvalues.clear();
    longsnames.clear();
    longsvalues.clear();
    ulongsnames.clear();
    ulongsvalues.clear();
    floatsnames.clear();
    floatsvalues.clear();
    doublesnames.clear();
    doublesvalues.clear();
    catsnames.clear();
    catsvalues.clear();
    textsnames.clear();
    textsvalues.clear();
} // ibis::table::row::clear

inline void ibis::table::row::clearValues() {
    bytesvalues.clear();
    ubytesvalues.clear();
    shortsvalues.clear();
    ushortsvalues.clear();
    intsvalues.clear();
    uintsvalues.clear();
    longsvalues.clear();
    ulongsvalues.clear();
    floatsvalues.clear();
    doublesvalues.clear();
    catsvalues.clear();
    textsvalues.clear();
} // ibis::table::row::clearValues

inline ibis::table* ibis::table::groupby(const char* str) const {
    stringList lst;
    char* buf = 0;
    if (str != 0 && *str != 0) {
        buf = new char[strlen(str)+1];
        strcpy(buf, str);
        parseNames(buf, lst);
    }
    ibis::table* res = groupby(lst);
    delete [] buf;
    return res;
} // ibis::table::groupby

inline void ibis::table::orderby(const char* str) {
    stringList lst;
    char* buf = 0;
    if (str != 0 && *str != 0) {
        buf = new char[strlen(str)+1];
        strcpy(buf, str);
        parseNames(buf, lst);
    }
    orderby(lst);
    delete [] buf;
} // ibis::table::orderby
#endif // IBIS_TABLE_H

Disclaimers FastBit source code FastBit mailing list archive Maintainer of this page