category.h

Go to the documentation of this file.

//File: $Id$
// Author: John Wu <John.Wu at ACM.org>
// Copyright 2000-2009 the Regents of the University of California
#ifndef IBIS_CATEGORY_H
#define IBIS_CATEGORY_H
#include "irelic.h"
#include "column.h"

class ibis::text : public ibis::column {
public:
    virtual ~text() {unloadIndex();};
    text(const part* tbl, FILE* file);
    text(const part* tbl, const char* name, ibis::TYPE_T t=ibis::TEXT);
    text(const ibis::column& col); // copy from column

    virtual long keywordSearch(const char* str, ibis::bitvector& hits) const;
    virtual long keywordSearch(const char* str) const;
//     long keywordSearch(const std::vector<std::string>& strs) const;
//     long keywordSearch(const std::vector<std::string>& strs,
//                     ibis::bitvector& hits) const;

    virtual long search(const char* str, ibis::bitvector& hits) const;
    virtual long search(const std::vector<std::string>& strs,
                        ibis::bitvector& hits) const;
    virtual long search(const char* str) const {
        ibis::bitvector tmp;
        long ierr = search(str, tmp);
        return (ierr < 0 ? ierr : tmp.cnt());
    }
    virtual long search(const std::vector<std::string>& strs) const {
        ibis::bitvector tmp;
        long ierr = search(strs, tmp);
        return (ierr < 0 ? ierr : tmp.cnt());
    }

    virtual double estimateCost(const ibis::qString& cmp) const;
    virtual double estimateCost(const ibis::qMultiString& cmp) const;
    virtual double estimateCost(const ibis::qContinuousRange& cmp) const {
        return ibis::column::estimateCost(cmp);}
    virtual double estimateCost(const ibis::qDiscreteRange& cmp) const {
        return ibis::column::estimateCost(cmp);}

    virtual long append(const char* dt, const char* df, const uint32_t nold,
                        const uint32_t nnew, uint32_t nbuf, char* buf);
    virtual long saveSelected(const ibis::bitvector& sel, const char *dest,
                              char *buf, uint32_t nbuf);
    virtual array_t<uint32_t>* selectUInts(const bitvector& mask) const;
    virtual array_t<int64_t>* selectLongs(const bitvector& mask) const;
    virtual
    std::vector<std::string>* selectStrings(const bitvector& mask) const;
    virtual const char* findString(const char* str) const;
    virtual void getString(uint32_t i, std::string &val) const {
        readString(i, val);}

    virtual void write(FILE* file) const; 
    virtual void print(std::ostream& out) const; 

    const column* IDColumnForKeywordIndex() const;

protected:
    void startPositions(const char *dir, char *buf, uint32_t nbuf) const;
    void readString(uint32_t i, std::string &val) const;
    int  readString(std::string&, int, long, long, char*, uint32_t,
                    uint32_t&, off_t&) const;
    int  writeStrings(const char *to, const char *from,
                      const char *spto, const char *spfrom,
                      ibis::bitvector &msk, const ibis::bitvector &sel,
                      char *buf, uint32_t nbuf) const;

private:
    text& operator=(const text&);
}; // ibis::text

class ibis::dictionary {
public:
    typedef std::map< const char*, uint32_t, ibis::lessi > wordList;

    ~dictionary() {clear();}
    dictionary(const dictionary& dic);
    dictionary() : svec(), s2i(), ncontig(1) {
        svec.push_back(const_cast<char*>(nullstring.c_str()));
    }

    uint32_t size() const {return s2i.size();}
    inline const char* operator[](uint32_t i) const;
    inline uint32_t operator[](const char* str) const;
    inline const char* find(const char* str) const;
    inline uint32_t insert(const char* str);
    inline uint32_t insertRaw(char* str);

    void clear();
    void read(const char* name);
    void write(const char* name) const;

protected:

    std::vector<char*> svec;
    wordList s2i;
    uint32_t ncontig;

    static std::string nullstring;
    void copy(const dictionary& rhs);

private:
    dictionary& operator=(const dictionary&);
}; // ibis::dictionary

class ibis::category : public ibis::text {
public:
    virtual ~category();
    category(const part* tbl, FILE* file);
    category(const part* tbl, const char* name);
    category(const ibis::column& col); // copy from column
    // a special construct for meta-tag attributes
    category(const part* tbl, const char* name, const char* value,
             const char* dir=0, uint32_t nevt=0);

    virtual long search(const char* str, ibis::bitvector& hits) const;
    virtual long search(const std::vector<std::string>& vals,
                        ibis::bitvector& hits) const;
    virtual long search(const char* str) const;
    virtual long search(const std::vector<std::string>& vals) const;

    virtual long likeSearch(const char* pat) const;
    virtual long likeSearch(const char* pat, ibis::bitvector &hits) const;
    virtual double estimateCost(const ibis::qLike& cmp) const;
    virtual double estimateCost(const ibis::qString& cmp) const;
    virtual double estimateCost(const ibis::qMultiString& cmp) const;
    virtual double estimateCost(const ibis::qContinuousRange& cmp) const {
        return ibis::column::estimateCost(cmp);}
    virtual double estimateCost(const ibis::qDiscreteRange& cmp) const {
        return ibis::column::estimateCost(cmp);}

    virtual long append(const char* dt, const char* df, const uint32_t nold,
                        const uint32_t nnew, uint32_t nbuf, char* buf);
    virtual array_t<uint32_t>* selectUInts(const bitvector& mask) const;
//     virtual
//     std::vector<std::string>* selectStrings(const bitvector& mask) const;
    virtual void getString(uint32_t i, std::string &val) const;

    virtual uint32_t getNumKeys() const {return dic.size();}
    virtual const char* getKey(uint32_t i) const {return dic[i];}
    virtual const char* isKey(const char* str) const {
        return dic.find(str);}

    virtual void write(FILE* file) const; 
    virtual void print(std::ostream& out) const; 

    ibis::relic* fillIndex(const char *dir=0) const;

private:
    // private member variables

    // dictionary is mutable in order to delay the reading of dictionary
    // from disk as late as possible
    mutable ibis::dictionary dic;

    // private member functions
    void prepareMembers() const;
    void readDictionary(const char *dir=0) const;

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

class ibis::blob : public ibis::column {
public:
    virtual ~blob() {};
    blob(const part*, FILE*);
    blob(const part*, const char*);
    blob(const ibis::column&);

    virtual long search(const char*, ibis::bitvector&) const {return -1;}

    virtual void computeMinMax() {}
    virtual void computeMinMax(const char*) {}
    virtual void computeMinMax(const char*, double&, double&) const {}
    virtual void loadIndex(const char*, int) const throw () {}
    virtual long indexSize() const {return -1;}
    virtual int  getValuesArray(void*) const {return -1;}

    virtual array_t<char>* selectBytes(const bitvector&) const {return 0;}
    virtual array_t<unsigned char>* selectUBytes(const bitvector&) const {return 0;}
    virtual array_t<int16_t>* selectShorts(const bitvector&) const {return 0;}
    virtual array_t<uint16_t>* selectUShorts(const bitvector&) const {return 0;}
    virtual array_t<int32_t>* selectInts(const bitvector&) const {return 0;}
    virtual array_t<uint32_t>* selectUInts(const bitvector&) const {return 0;}
    virtual array_t<int64_t>* selectLongs(const bitvector&) const {return 0;}
    virtual array_t<uint64_t>* selectULongs(const bitvector&) const {return 0;}
    virtual array_t<float>* selectFloats(const bitvector&) const {return 0;}
    virtual array_t<double>* selectDoubles(const bitvector&) const {return 0;}
    virtual std::vector<std::string>* selectStrings(const bitvector&) const {return 0;}

    virtual long estimateRange(const ibis::qContinuousRange&,
                               ibis::bitvector&,
                               ibis::bitvector&) const {return -1;}
    virtual long estimateRange(const ibis::qDiscreteRange&,
                               ibis::bitvector&,
                               ibis::bitvector&) const {return -1;}
    virtual long evaluateRange(const ibis::qContinuousRange&,
                               const ibis::bitvector&,
                               ibis::bitvector&) const {return -1;}
    virtual long evaluateRange(const ibis::qDiscreteRange&,
                               const ibis::bitvector&,
                               ibis::bitvector&) const {return -1;}
    virtual long estimateRange(const ibis::qContinuousRange&) const {return -1;}
    virtual long estimateRange(const ibis::qDiscreteRange&) const {return -1;}
    virtual double estimateCost(const ibis::qContinuousRange&) const {return 0;}
    virtual double estimateCost(const ibis::qDiscreteRange& cmp) const {return 0;}
    virtual double estimateCost(const ibis::qString&) const {return 0;}
    virtual double estimateCost(const ibis::qMultiString&) const {return 0;}

    virtual float getUndecidable(const ibis::qContinuousRange&,
                                 ibis::bitvector&) const {return 1;}
    virtual float getUndecidable(const ibis::qDiscreteRange&,
                                 ibis::bitvector&) const {return 1;}

    virtual double getActualMin() const {return DBL_MAX;}
    virtual double getActualMax() const {return -DBL_MAX;}
    virtual double getSum() const {return 0;}
    virtual long append(const void*, const ibis::bitvector&) {return -1;}

    virtual long append(const char* dt, const char* df, const uint32_t nold,
                        const uint32_t nnew, uint32_t nbuf, char* buf);
    virtual long writeData(const char* dir, uint32_t nold, uint32_t nnew,
                           ibis::bitvector& mask, const void *va1,
                           void *va2);

    virtual void write(FILE*) const;
    virtual void print(std::ostream&) const;

    long countRawBytes(const bitvector&) const;
    int selectRawBytes(const bitvector&,
                       array_t<unsigned char>&, array_t<uint32_t>&) const;
    int getBlob(uint32_t ind, unsigned char *&buf, uint32_t &size) const;

protected:
    int extractAll(const bitvector&,
                   array_t<unsigned char>&, array_t<uint32_t>&,
                   const array_t<unsigned char>&,
                   const array_t<int64_t>&) const;
    int extractSome(const bitvector&,
                    array_t<unsigned char>&, array_t<uint32_t>&,
                    const array_t<unsigned char>&, const array_t<int64_t>&,
                    const uint32_t) const;
    int extractAll(const bitvector&,
                   array_t<unsigned char>&, array_t<uint32_t>&,
                   const char*, const array_t<int64_t>&) const;
    int extractSome(const bitvector&,
                    array_t<unsigned char>&, array_t<uint32_t>&,
                    const char*, const array_t<int64_t>&, const uint32_t) const;
    int extractSome(const bitvector&,
                    array_t<unsigned char>&, array_t<uint32_t>&,
                    const char*, const char*, const uint32_t) const;
    int readBlob(uint32_t ind, unsigned char *&buf, uint32_t &size,
                 const array_t<int64_t> &starts, const char *datafile) const;
    int readBlob(uint32_t ind, unsigned char *&buf, uint32_t &size,
                 const char *spfile, const char *datafile) const;
}; // ibis::blob

inline const char* ibis::dictionary::operator[](uint32_t i) const {
    if (i < svec.size()) {
        return svec[i];
    }
    else {
        return static_cast<const char*>(0);
    }
} // int to string

inline uint32_t ibis::dictionary::operator[](const char* str) const {
    if (str == 0) return 0;
    if (*str == 0) return 0;
    wordList::const_iterator it = s2i.find(str);
    if (it != s2i.end()) return (*it).second;
    else return svec.size();
} // string to int

inline const char* ibis::dictionary::find(const char* str) const {
    const char* ret = 0;
    if (s2i.find(str) != s2i.end())
        ret = str;
    return ret;
} // ibis::dictionary::find

inline uint32_t ibis::dictionary::insert(const char* str) {
    if (str == 0) return 0;
    if (*str == 0) return 0;
    wordList::const_iterator it = s2i.find(str);
    if (it != s2i.end()) {
        return (*it).second;
    }
    else {
        uint32_t ret = svec.size();
        char* tmp = ibis::util::strnewdup(str); // make a copy
        svec.push_back(tmp);
        s2i[tmp] = ret;
        return ret;
    }
} // ibis::dictionary::insert

inline uint32_t ibis::dictionary::insertRaw(char* str) {
    if (str == 0) return 0;
    if (*str == 0) return 0;
    wordList::const_iterator it = s2i.find(str);
    if (it != s2i.end()) {
        return (*it).second;
    }
    else {
        uint32_t ret = svec.size();
        svec.push_back(str);
        s2i[str] = ret;
        return ret;
    }
} // ibis::dictionary::insertRaw
#endif // IBIS_CATEGORY_H

	Contact us Disclaimers FastBit source code FastBit mailing list archive