category.h

Go to the documentation of this file.

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









#include "column.h"     // ibis::column
#include "dictionary.h" // ibis::dictionary
#include "idirekte.h"   // ibis::direkte

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 stringSearch(const char* str, ibis::bitvector& hits) const;
    virtual long stringSearch(const std::vector<std::string>& strs,
                              ibis::bitvector& hits) const;
    virtual long stringSearch(const char* str) const;
    virtual long stringSearch(const std::vector<std::string>& strs) const;
    virtual long patternSearch(const char*, ibis::bitvector&) const;
    virtual long patternSearch(const char*) const;

    using ibis::column::estimateCost;
    virtual double estimateCost(const ibis::qString& cmp) const;
    virtual double estimateCost(const ibis::qMultiString& cmp) const;

    virtual void loadIndex(const char* iopt=0, int ropt=0) const throw ();
    virtual long append(const char* dt, const char* df, const uint32_t nold,
                        const uint32_t nnew, uint32_t nbuf, char* buf);
    virtual long append(const void*, const ibis::bitvector&) {return -1;}
    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;
    void TDListForKeywordIndex(std::string&) const;
    void delimitersForKeywordIndex(std::string&) const;

    struct tokenizer {
        virtual int operator()(std::vector<const char*>& tkns, char *buf) = 0;
        virtual ~tokenizer() {}
    }; // struct tokenizer

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::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 stringSearch(const char* str, ibis::bitvector& hits) const;
    virtual long stringSearch(const std::vector<std::string>& vals,
                              ibis::bitvector& hits) const;
    virtual long stringSearch(const char* str) const;
    virtual long stringSearch(const std::vector<std::string>& vals) const;

    virtual long patternSearch(const char* pat) const;
    virtual long patternSearch(const char* pat, ibis::bitvector &hits) const;
    using ibis::text::estimateCost;
    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 void loadIndex(const char* =0, int =0) const throw ();
    virtual long append(const char* dt, const char* df, const uint32_t nold,
                        const uint32_t nnew, uint32_t nbuf, char* buf);
    virtual long append(const void*, const ibis::bitvector&) {return -1;}
    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;
    virtual const char* getKey(uint32_t i) const;
    virtual const char* isKey(const char* str) const;

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

    ibis::direkte* fillIndex(const char *dir=0) const;
    const ibis::dictionary* getDictionary() const {return &dic;}
    int setDictionary(const dictionary&);

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 stringSearch(const char*, ibis::bitvector&) const {return -1;}
    virtual long stringSearch(const std::vector<std::string>&,
                              ibis::bitvector&) const {return -1;}
    virtual long stringSearch(const char*) const {return -1;}
    virtual long stringSearch(const std::vector<std::string>&) 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<signed 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
#endif // IBIS_CATEGORY_H