bundle.h

Go to the documentation of this file.

//File: $Id$
// Author: John Wu <John.Wu at ACM.org>
//         Lawrence Berkeley National Laboratory
// Copyright 2000-2012 the Regents of the University of California
#ifndef IBIS_BUNDLE_H
#define IBIS_BUNDLE_H











#include "query.h"      // ibis::query, ibis::selectClause
#include "colValues.h"  // ibis::colValues

namespace ibis {
    // class bundle defined in const.h,
    // the following are concrete classes used in the implementation
    class bundle0;
    class bundle1;
    //class bundle2s;
    //class bundle2t;
    class bundles;
    //class bundlet;
}

class FASTBIT_CXX_DLLSPEC ibis::bundle {
public:
    static bundle* create(const ibis::query&, int =0);
    static bundle* create(const ibis::query&, const ibis::bitvector&, int =0);
    static bundle* create(const ibis::part&, const ibis::selectClause&, int =0);

    static const ibis::RIDSet* readRIDs(const char* dir, const uint32_t i);

    virtual uint32_t size() const {
        return (starts != 0 && starts->size()>0 ? starts->size()-1 : 0);}
    virtual uint32_t width() const {return 0;}
    virtual void print(std::ostream& out) const = 0;
    virtual void printAll(std::ostream& out) const = 0;
    virtual void printColumnNames(std::ostream& out) const = 0;
    virtual int32_t  getInt(uint32_t, uint32_t) const;
    virtual uint32_t getUInt(uint32_t, uint32_t) const;
    virtual int64_t  getLong(uint32_t, uint32_t) const;
    virtual uint64_t getULong(uint32_t, uint32_t) const;
    virtual float    getFloat(uint32_t, uint32_t) const;
    virtual double   getDouble(uint32_t, uint32_t) const;
    virtual std::string getString(uint32_t, uint32_t) const;

    virtual ibis::TYPE_T columnType(uint32_t) const {
        return ibis::UNKNOWN_TYPE;}
    virtual void* columnArray(uint32_t) const {return 0;}
    virtual const ibis::column* columnPointer(uint32_t) const {return 0;}

    virtual void reorder(const char *) = 0;
    virtual long truncate(uint32_t keep) = 0;
    virtual long truncate(uint32_t keep, uint32_t start) = 0;
    virtual long truncate(const char *names, uint32_t keep) = 0;

    virtual ~bundle();
    virtual void write(const ibis::query& q) const = 0;

    // some utility functions
    void sortRIDs(uint32_t i, uint32_t j);
    void swapRIDs(uint32_t i, uint32_t j) { // no error checking!
        if (rids) {
            ibis::rid_t tmp = (*rids)[i];
            (*rids)[i] = (*rids)[j];
            (*rids)[j] = tmp;
        }
    };
    uint32_t numRowsInBundle(uint32_t ind) const {
        if (starts != 0 && ind+1 < starts->size()) {
            return (*starts)[ind+1]-(*starts)[ind];
        }
        else {
            return 0U;
        }
    }
    uint32_t rowCounts(array_t<uint32_t>& cnt) const;

    const ibis::RIDSet* getRIDs(uint32_t ind) const {
        if (rids != 0 && starts != 0 && ind+1 < starts->size()) {
            return new ibis::RIDSet(*rids, (*starts)[ind], (*starts)[ind+1]);
        }
        else {
            return static_cast<ibis::RIDSet*>(0);
        }
    };
    const ibis::RIDSet* getRIDs() const {return rids;}
    const ibis::array_t<uint32_t>* getStarts() const {return starts;}

protected:
    const ibis::selectClause& comps;
    array_t<uint32_t>* starts; // starting positions of bundles (in rids)
    ibis::RIDSet* rids;
    const char* id;
    mutable bool infile; // is the current content in file?

    // Hides constructors from others.
    bundle(const ibis::selectClause& c)
        : comps(c), starts(0), rids(0), id(""), infile(false) {};
    // use ibis::query::getRIDs(const ibis::bitvector&) const to avoid the
    // read lock required by ibis::query::getRIDs() const.
    explicit bundle(const ibis::query &q)
        : comps(q.components()), starts(0),
          rids(q.getRIDs(*(q.getHitVector()))), id(q.id()),
          infile(false) {
        if (rids != 0 && static_cast<long>(rids->size()) != q.getNumHits()) {
            delete rids;
            rids = 0;
        }
    };
    bundle(const ibis::query &q, const ibis::bitvector& hits)
        : comps(q.components()), starts(0), rids(q.getRIDs(hits)),
          id(q.id()), infile(false) {};
    bundle(const ibis::part &t, const ibis::selectClause &s)
        : comps(s), starts(new array_t<uint32_t>), rids(t.getRIDs()),
        id(t.name()), infile(false) {
        starts->resize(2);
        (*starts)[0] = 0;
        (*starts)[1] = t.nRows();
    }

private:
    bundle(); // no default constructor
    bundle(const bundle&); // no copy constructor
    bundle& operator=(const bundle&); // no assignment operator
}; // class ibis::bundle

class FASTBIT_CXX_DLLSPEC ibis::bundle0 : public ibis::bundle {
public:
    explicit bundle0(const ibis::query& q);
    bundle0(const ibis::query& q, const ibis::bitvector& hits);
    bundle0(const ibis::part& t, const ibis::selectClause &s);

    virtual void print(std::ostream& out) const;
    virtual void printAll(std::ostream& out) const;
    virtual void printColumnNames(std::ostream&) const {};

    // can not do anything
    virtual void reorder(const char *) {};
    // only one bundle.
    virtual long truncate(uint32_t) {return 1;}
    virtual long truncate(uint32_t, uint32_t) {return 1;}
    virtual long truncate(const char *, uint32_t) {return 1;}

    virtual void write(const ibis::query& q) const {
        if (rids != 0 && infile == false) {
            q.writeRIDs(rids);
            infile = true;
        }
    }
}; // ibis::bundle0

class FASTBIT_CXX_DLLSPEC ibis::bundle1 : public ibis::bundle {
public:
    explicit bundle1(const ibis::query&, int =0);
    bundle1(const ibis::query&, const ibis::bitvector&, int =0);
    bundle1(const ibis::part&, const ibis::selectClause&, int =0);
    virtual ~bundle1();

    virtual uint32_t size() const {return (col ? col->size() : 0);}
    virtual uint32_t width() const {return 1;}

    virtual void write(const ibis::query&) const;
    virtual void print(std::ostream& out) const;
    virtual void printAll(std::ostream& out) const;
    virtual void printColumnNames(std::ostream& out) const;

    virtual int32_t     getInt(uint32_t, uint32_t) const;
    virtual uint32_t    getUInt(uint32_t, uint32_t) const;
    virtual int64_t     getLong(uint32_t, uint32_t) const;
    virtual uint64_t    getULong(uint32_t, uint32_t) const;
    virtual float       getFloat(uint32_t, uint32_t) const;
    virtual double      getDouble(uint32_t, uint32_t) const;
    virtual std::string getString(uint32_t, uint32_t) const;

    virtual const ibis::column* columnPointer(uint32_t j) const {
        return (j == 0 ? col->columnPointer() :
                static_cast<const ibis::column*>(0));}
    virtual ibis::TYPE_T columnType(uint32_t j) const {
        return (j == 0 ? col->getType() : ibis::UNKNOWN_TYPE);}
    virtual void* columnArray(uint32_t j) const {
        return (j == 0 ? col->getArray() : 0);}

    virtual void reorder(const char *) {
        // if (direc.size() > 0 && direc[0] == false) {
        //     reverse();
        //     infile = false;
        // }
    }
    virtual long truncate(uint32_t);
    virtual long truncate(uint32_t, uint32_t);
    virtual long truncate(const char *, uint32_t keep);

private:
    ibis::colValues* col;
    ibis::selectClause::AGREGADO aggr;

    void sort(int);
    void reverse();

    bundle1();
    bundle1(const bundle1&);
    bundle1& operator=(const bundle1&);
}; // ibis::bundle1

class FASTBIT_CXX_DLLSPEC ibis::bundles : public ibis::bundle {
public:
    explicit bundles(const ibis::query&, int =0);
    bundles(const ibis::query&, const ibis::bitvector&, int =0);
    bundles(const ibis::part&, const ibis::selectClause&, int =0);
    virtual ~bundles() {clear();}

    virtual uint32_t size() const {
        return (cols.empty() ? 0 : cols.back()->size());}
    virtual uint32_t width() const {return cols.size();}

    virtual void print(std::ostream& out) const;
    virtual void printAll(std::ostream& out) const;
    virtual void printColumnNames(std::ostream& out) const;
    virtual void write(const ibis::query&) const;

    virtual int32_t     getInt(uint32_t, uint32_t) const;
    virtual uint32_t    getUInt(uint32_t, uint32_t) const;
    virtual int64_t     getLong(uint32_t, uint32_t) const;
    virtual uint64_t    getULong(uint32_t, uint32_t) const;
    virtual float       getFloat(uint32_t, uint32_t) const;
    virtual double      getDouble(uint32_t, uint32_t) const;
    virtual std::string getString(uint32_t, uint32_t) const;

    virtual const ibis::column* columnPointer(uint32_t j) const {
        return (j < cols.size() ? cols[j]->columnPointer() :
                static_cast<const ibis::column*>(0));}
    virtual ibis::TYPE_T columnType(uint32_t j) const {
        return (j < cols.size() ? cols[j]->getType() : ibis::UNKNOWN_TYPE);}
    virtual void* columnArray(uint32_t j) const {
        return (j < cols.size() ? cols[j]->getArray() : 0);}

    virtual void reorder(const char *);
    virtual long truncate(uint32_t keep);
    virtual long truncate(uint32_t keep, uint32_t start);
    virtual long truncate(const char *names, uint32_t keep);

private:
    colList cols;
    std::vector<ibis::selectClause::AGREGADO> aggr;

    void sort(int);
    void clear();
    void reverse();

    bundles();
    bundles(const bundles&);
    bundles& operator=(const bundles&);
}; // ibis::bundles

class FASTBIT_CXX_DLLSPEC ibis::query::result {
public:
    result(ibis::query& q);
    ~result();

    uint32_t width() const {return(bdl_!=0 ? bdl_->width() : 0U);}

    bool next();
    bool nextBundle();
    void reset();

    int32_t getInt(const char *cname) const;
    uint32_t getUInt(const char *cname) const;
    int64_t getLong(const char *cname) const;
    uint64_t getULong(const char *cname) const;
    float getFloat(const char *cname) const;
    double getDouble(const char *cname) const;
    std::string getString(const char *cname) const;

    int32_t getInt(uint32_t selind) const {
        return bdl_->getInt(bid_-1, selind);
    }
    uint32_t getUInt(uint32_t selind) const {
        return bdl_->getUInt(bid_-1, selind);
    }
    int64_t getLong(uint32_t selind) const {
        return bdl_->getLong(bid_-1, selind);
    }
    uint64_t getULong(uint32_t selind) const {
        return bdl_->getULong(bid_-1, selind);
    }
    float getFloat(uint32_t selind) const {
        return bdl_->getFloat(bid_-1, selind);
    }
    double getDouble(uint32_t selind) const {
        return bdl_->getDouble(bid_-1, selind);
    }

    std::string getString(uint32_t selind) const {
        return bdl_->getString(bid_-1, selind);
    }
    inline uint32_t colPosition(const char *cname) const
    {return sel.find(cname);}

    void printColumnNames(std::ostream& out) const {
        if (bdl_ != 0) {
            bdl_->printColumnNames(out);
        }
    }

private:
    ibis::query &que_;
    ibis::bundle *bdl_;
    const ibis::selectClause& sel;
    uint32_t bid_; // 0 for unused.
    uint32_t lib_; // results left in the bundle.

    result();
    result(const result&);
    result& operator=(const result&);
}; // ibis::query::result
#endif // IBIS_BUNDLE_H