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-2011 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& q);
    static bundle* create(const ibis::query& q, const ibis::bitvector& hits);
    static bundle* create(const ibis::part& p, const ibis::selectClause& sel);

    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) : 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 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 void reorder(const char *, int) = 0;
    virtual long truncate(uint32_t keep) = 0;
    virtual long truncate(uint32_t keep, uint32_t start) = 0;
    virtual long truncate(const char *names, int direction, 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) {};

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) : bundle(q) {q.writeRIDs(rids);};
    bundle0(const ibis::query& q, const ibis::bitvector& hits)
        : bundle(q, hits) {
        if (rids != 0 && static_cast<long>(rids->size()) != q.getNumHits()) {
            delete rids;
            rids = 0;
        }
    };

    virtual uint32_t size() const {return (rids ? rids->size() : 0);}
    virtual void print(std::ostream& out) const;
    virtual void printAll(std::ostream& out) const;

    // can not do anything
    virtual void reorder(const char *, int) {};
    // only one bundle.
    virtual long truncate(uint32_t) {return 1;}
    virtual long truncate(uint32_t, uint32_t) {return 1;}
    virtual long truncate(const char *, int, 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& q);
    bundle1(const ibis::query& q, const ibis::bitvector& hits);
    bundle1(const ibis::part& tbl, const ibis::selectClause& sel);
    virtual ~bundle1();
    virtual void write(const ibis::query&) const;

    virtual uint32_t size() const {return (col ? col->size() : 0);}
    virtual uint32_t width() const {return 1;}
    // print the bundle values to the specified output stream
    virtual void print(std::ostream& out) const;
    // print the bundle values along with the RIDs
    virtual void printAll(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 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 *, int direction) {
        if (direction < 0) {
            reverse();
            infile = false;
        }
    }
    virtual long truncate(uint32_t);
    virtual long truncate(uint32_t, uint32_t);
    virtual long truncate(const char *, int direction, uint32_t keep) {
        if (direction < 0) {
            reverse();
            infile = false;
        }
        return truncate(keep);
    }

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

    void sort();
    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& q);
    bundles(const ibis::query& q, const ibis::bitvector& hits);
    bundles(const ibis::part& tbl, const ibis::selectClause& sel);
    virtual ~bundles() {clear();}
    virtual void write(const ibis::query&) const;

    virtual uint32_t size() const {
        return (cols.empty() ? 0 : cols.back()->size());}
    virtual uint32_t width() const {return cols.size();}
    // print the bundle values to the specified output stream
    virtual void print(std::ostream& out) const;
    // print the bundle values along with the RIDs
    virtual void printAll(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 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 *names, int direction);
    virtual long truncate(uint32_t keep);
    virtual long truncate(uint32_t keep, uint32_t start);
    virtual long truncate(const char *names, int direction, uint32_t keep);

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

    void sort();
    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();

    bool next();
    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);}

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