FastBit: part.h Source File (ibis1.1.5)

00001 // File: $Id$
00002 // Author: John Wu <John.Wu at ACM.org>
00003 // Copyright 2000-2009 the Regents of the University of California
00004 #ifndef IBIS_PART_H
00005 #define IBIS_PART_H
00012 #include "column.h"
00013 #include "resource.h"
00014 #include "utilidor.h"
00015 
00016 #include <string>
00017 #include <vector>
00018 
00024 class FASTBIT_CXX_DLLSPEC ibis::part {
00025 public:
00026     enum TABLE_STATE {
00027         UNKNOWN_STATE=0, STABLE_STATE, RECEIVING_STATE,
00028         PRETRANSITION_STATE, TRANSITION_STATE, POSTTRANSITION_STATE
00029     };
00030     struct info; // To hold some basic information about a table.
00031     class readLock;
00032 
00033     /******************************************************************/
00034     // public functions
00035     /******************************************************************/
00036 
00038     virtual ~part();
00041     explicit part(const char* prefix=0);
00044     part(const char* adir, const char* bdir);
00046     part(const std::vector<const char*> &mtags);
00048     part(const ibis::resource::vList &mtags);
00049 
00051     inline info* getInfo() const;
00053     TABLE_STATE getState() const;
00054     TABLE_STATE getStateNoLocking() const {return state;}
00055 
00057     void buildIndexes(const char* opt=0, int nthr=1);
00059     void buildSorted(const char* colname) const;
00061     void loadIndexes(const char* opt=0, int readall=0) const;
00062     void unloadIndexes() const;
00063     void purgeIndexFiles() const;
00064 
00066     const char* name()          const {return m_name;}
00068     const char* description()   const {return m_desc.c_str();}
00070     const char* indexSpec()     const {return idxstr;}
00072     void indexSpec(const char*);
00074     time_t      timestamp()     const {return switchTime;}
00077     std::string metaTags()      const;
00080     inline column* getColumn(const char* name) const;
00082     inline column* getColumn(uint32_t ind) const;
00083 
00085     const char* currentDataDir() const {return activeDir;}
00087     uint32_t nColumns() const {return columns.size();}
00089     uint32_t nRows() const {return nEvents;}
00090 
00092     void print(std::ostream &out) const;
00093 
00095     bool matchNameValuePair(const char* name, const char* value) const;
00098     bool matchMetaTags(const std::vector<const char*> &mtags) const;
00100     bool matchMetaTags(const ibis::resource::vList &mtags) const;
00102     inline const char* getMetaTag(const char*) const;
00103 
00105     virtual long selfTest(int nth=1, const char* pref=0) const;
00108     void computeMinMax();
00109 
00110     /******************************************************************/
00111     // The following functions need to hold a read lock on the partition,
00112     // however in order for them to produce consistent results, they must
00113     // share the same read lock.  These functions do not contain the lock
00114     // themselves, but rely on the caller to maintain a consistent lock.
00115     /******************************************************************/
00117     uint32_t getRowNumber(const rid_t &rid) const;
00118     long evaluateRIDSet(const ibis::RIDSet&, ibis::bitvector&) const; 
00119     array_t<rid_t>* getRIDs() const {return rids;} // all RIDs
00120     array_t<rid_t>* getRIDs(const ibis::bitvector &mask) const;// some RIDs
00121     bool hasRIDs() const {return (rids!=0) ? (rids->size()==nEvents) : false;}
00122 
00124     virtual double estimateCost(const ibis::qContinuousRange &cmp) const;
00125     virtual double estimateCost(const ibis::qDiscreteRange &cmp) const;
00126     virtual double estimateCost(const ibis::qString &cmp) const;
00127     virtual double estimateCost(const ibis::qMultiString &cmp) const;
00128 
00130     virtual long estimateRange(const ibis::qContinuousRange &cmp) const;
00131 
00133     virtual long estimateRange(const ibis::qDiscreteRange &cmp) const;
00135     virtual long evaluateRange(const ibis::qContinuousRange &cmp,
00136                                const ibis::bitvector &mask,
00137                                ibis::bitvector &res) const;
00139     virtual long evaluateRange(const ibis::qDiscreteRange &cmp,
00140                                const ibis::bitvector &mask,
00141                                ibis::bitvector &res) const;
00142 
00144     virtual long estimateRange(const ibis::qContinuousRange &cmp,
00145                                ibis::bitvector &low,
00146                                ibis::bitvector &high) const;
00147 
00149     virtual float getUndecidable(const ibis::qContinuousRange &cmp,
00150                                  ibis::bitvector &iffy) const;
00151 
00153     virtual long estimateRange(const ibis::qDiscreteRange &cmp,
00154                                ibis::bitvector &low,
00155                                ibis::bitvector &high) const;
00157     virtual float getUndecidable(const ibis::qDiscreteRange &cmp,
00158                                  ibis::bitvector &iffy) const;
00159 
00162     virtual long doScan(const ibis::qRange &cmp,
00163                         ibis::bitvector &hits) const;
00166     virtual long doScan(const ibis::qRange &cmp,
00167                         const ibis::bitvector &mask,
00168                         ibis::bitvector &hits) const;
00171     virtual long negativeScan(const ibis::qRange &cmp,
00172                               const ibis::bitvector &mask,
00173                               ibis::bitvector &hits) const;
00174 
00176     virtual long doScan(const ibis::compRange &cmp,
00177                         ibis::bitvector &hits) const;
00180     virtual long doScan(const ibis::compRange &cmp,
00181                         const ibis::bitvector &mask,
00182                         ibis::bitvector &hits,
00183                         ibis::math::barrel* bar=0) const;
00184 
00186     template <typename E>
00187         static long doScan(const array_t<E> &varr,
00188                            const ibis::qRange &cmp,
00189                            const ibis::bitvector &mask,
00190                            ibis::bitvector &hits);
00193     template <typename E>
00194         static long doScan(const array_t<E> &varr,
00195                            const ibis::qContinuousRange &cmp,
00196                            const ibis::bitvector &mask,
00197                            ibis::bitvector &hits);
00198 
00200     long countHits(const ibis::qRange &cmp) const;
00201 
00206     virtual long estimateMatchAny(const ibis::qAnyAny &cmp,
00207                                   ibis::bitvector &low,
00208                                   ibis::bitvector &high) const;
00209     virtual long matchAny(const ibis::qAnyAny &cmp,
00210                           ibis::bitvector &hits) const;
00211     virtual long matchAny(const ibis::qAnyAny &cmp,
00212                           const ibis::bitvector &mask,
00213                           ibis::bitvector &hits) const;
00214 
00215     long likeSearch(const ibis::qLike &cmp,
00216                     ibis::bitvector &low) const;
00217     long lookforString(const ibis::qString &cmp,
00218                        ibis::bitvector &low) const;
00219     long lookforString(const ibis::qMultiString &cmp,
00220                        ibis::bitvector &low) const;
00221     long likeSearch(const ibis::qLike &cmp) const;
00222     long lookforString(const ibis::qString &cmp) const;
00223     long lookforString(const ibis::qMultiString &cmp) const;
00224 
00229     int64_t evaluateJoin(const ibis::rangeJoin &cmp,
00230                          const ibis::bitvector &mask,
00231                          ibis::bitvector64 &pairs) const;
00234     int64_t evaluateJoin(const ibis::rangeJoin &cmp,
00235                          const ibis::bitvector &mask,
00236                          const char* pairfile) const;
00238     int64_t evaluateJoin(const ibis::rangeJoin &cmp,
00239                          const ibis::bitvector &mask) const;
00242     int64_t evaluateJoin(const std::vector<const ibis::rangeJoin*> &cmp,
00243                          const ibis::bitvector &mask,
00244                          ibis::bitvector64 &pairs) const;
00245     int64_t evaluateJoin(const std::vector<const ibis::rangeJoin*> &cmp,
00246                          const ibis::bitvector &mask) const;
00251     int64_t evaluateJoin(const ibis::rangeJoin &cmp,
00252                          const ibis::bitvector64 &trial,
00253                          ibis::bitvector64 &result) const;
00254     int64_t evaluateJoin(const std::vector<const ibis::rangeJoin*> &cmp,
00255                          const ibis::bitvector64 &trial,
00256                          ibis::bitvector64 &result) const;
00257     /******************************************************************/
00258 
00260     array_t<char>*
00261         selectBytes(const char* name, const ibis::bitvector &mask) const;
00263     array_t<unsigned char>*
00264         selectUBytes(const char* name, const ibis::bitvector &mask) const;
00266     array_t<int16_t>*
00267         selectShorts(const char* name, const ibis::bitvector &mask) const;
00269     array_t<uint16_t>*
00270         selectUShorts(const char* name, const ibis::bitvector &mask) const;
00272     array_t<int32_t>*
00273         selectInts(const char* name, const ibis::bitvector &mask) const;
00275     array_t<uint32_t>*
00276         selectUInts(const char* name, const ibis::bitvector &mask) const;
00278     array_t<int64_t>*
00279         selectLongs(const char* name, const ibis::bitvector &mask) const;
00281     array_t<uint64_t>*
00282         selectULongs(const char* name, const ibis::bitvector &mask) const;
00284     array_t<float>*
00285         selectFloats(const char* name, const ibis::bitvector &mask) const;
00287     array_t<double>*
00288         selectDoubles(const char* name, const ibis::bitvector &mask) const;
00290     std::vector<std::string>*
00291         selectStrings(const char* name, const ibis::bitvector &mask) const;
00293     long calculate(const ibis::math::term&, const ibis::bitvector&,
00294                    array_t<double>&) const;
00295 
00296     /******************************************************************/
00297     // A group of functions added August, 2005 to provide summary
00298     // information about the data.  Logically, they are a extension of
00299     // getInfo.
00300 
00302     double getActualMin(const char *name) const;
00304     double getActualMax(const char *name) const;
00306     double getColumnSum(const char *name) const;
00307 
00311     long get1DDistribution(const char *constraints, const char *cname,
00312                            double begin, double end, double stride,
00313                            std::vector<uint32_t> &counts) const;
00315     long get2DDistribution(const char *constraints, const char *cname1,
00316                            double begin1, double end1, double stride1,
00317                            const char *cname2,
00318                            double begin2, double end2, double stride2,
00319                            std::vector<uint32_t> &counts) const;
00321     long get3DDistribution(const char *constraints, const char *cname1,
00322                            double begin1, double end1, double stride1,
00323                            const char *cname2,
00324                            double begin2, double end2, double stride2,
00325                            const char *cname3,
00326                            double begin3, double end3, double stride3,
00327                            std::vector<uint32_t> &counts) const;
00329     long get1DDistribution(const char *constraints, const char *cname,
00330                            double begin, double end, double stride,
00331                            const char *wtname,
00332                            std::vector<double> &weights) const;
00334     long get2DDistribution(const char *constraints, const char *cname1,
00335                            double begin1, double end1, double stride1,
00336                            const char *cname2,
00337                            double begin2, double end2, double stride2,
00338                            const char *wtname,
00339                            std::vector<double> &weights) const;
00341     long get3DDistribution(const char *constraints, const char *cname1,
00342                            double begin1, double end1, double stride1,
00343                            const char *cname2,
00344                            double begin2, double end2, double stride2,
00345                            const char *cname3,
00346                            double begin3, double end3, double stride3,
00347                            const char *wtname,
00348                            std::vector<double> &weights) const;
00350     long get1DDistribution(const char *cname, uint32_t nbin,
00351                            std::vector<double> &bounds,
00352                            std::vector<uint32_t> &counts) const;
00354     long get1DDistribution(const char *constraints,
00355                            const char *cname, uint32_t nbin,
00356                            std::vector<double> &bounds,
00357                            std::vector<uint32_t> &counts) const;
00359     long get2DDistribution(const char *cname1, const char *cname2,
00360                            uint32_t nb1, uint32_t nb2,
00361                            std::vector<double> &bounds1,
00362                            std::vector<double> &bounds2,
00363                            std::vector<uint32_t> &counts,
00364                            const char* const option=0) const;
00366     long get2DDistribution(const char *constraints,
00367                            const char *name1, const char *name2,
00368                            uint32_t nb1, uint32_t nb2,
00369                            std::vector<double> &bounds1,
00370                            std::vector<double> &bounds2,
00371                            std::vector<uint32_t> &counts) const;
00373     long get3DDistribution(const char *cname1, const char *cname2,
00374                            const char *cname3,
00375                            uint32_t nb1, uint32_t nb2, uint32_t nb3,
00376                            std::vector<double> &bounds1,
00377                            std::vector<double> &bounds2,
00378                            std::vector<double> &bounds3,
00379                            std::vector<uint32_t> &counts,
00380                            const char* const option=0) const;
00382     long get3DDistribution(const char *constraints,
00383                            const char *cname1, const char *cname2,
00384                            const char *cname3,
00385                            uint32_t nb1, uint32_t nb2, uint32_t nb3,
00386                            std::vector<double> &bounds1,
00387                            std::vector<double> &bounds2,
00388                            std::vector<double> &bounds3,
00389                            std::vector<uint32_t> &counts) const;
00391     long get1DBins(const char *constraints, const char *cname,
00392                    double begin, double end, double stride,
00393                    std::vector<ibis::bitvector> &bins) const;
00395     long get1DBins(const char *constraints, const char *cname,
00396                    double begin, double end, double stride,
00397                    std::vector<ibis::bitvector*> &bins) const;
00399     long get1DBins(const char *constraints, const char *cname,
00400                    double begin, double end, double stride,
00401                    const char *wtname,
00402                    std::vector<double> &weights,
00403                    std::vector<ibis::bitvector*> &bins) const;
00405     long get2DBins(const char *constraints, const char *cname1,
00406                    double begin1, double end1, double stride1,
00407                    const char *cname2,
00408                    double begin2, double end2, double stride2,
00409                    std::vector<ibis::bitvector> &bins) const;
00411     long get2DBins(const char *constraints, const char *cname1,
00412                    double begin1, double end1, double stride1,
00413                    const char *cname2,
00414                    double begin2, double end2, double stride2,
00415                    std::vector<ibis::bitvector*> &bins) const;
00417     long get2DBins(const char *constraints, const char *cname1,
00418                    double begin1, double end1, double stride1,
00419                    const char *cname2,
00420                    double begin2, double end2, double stride2,
00421                    const char *wtname,
00422                    std::vector<double> &weights,
00423                    std::vector<ibis::bitvector*> &bins) const;
00425     long get3DBins(const char *constraints, const char *cname1,
00426                    double begin1, double end1, double stride1,
00427                    const char *cname2,
00428                    double begin2, double end2, double stride2,
00429                    const char *cname3,
00430                    double begin3, double end3, double stride3,
00431                    std::vector<ibis::bitvector> &bins) const;
00433     long get3DBins(const char *constraints, const char *cname1,
00434                    double begin1, double end1, double stride1,
00435                    const char *cname2,
00436                    double begin2, double end2, double stride2,
00437                    const char *cname3,
00438                    double begin3, double end3, double stride3,
00439                    std::vector<ibis::bitvector*> &bins) const;
00441     long get3DBins(const char *constraints, const char *cname1,
00442                    double begin1, double end1, double stride1,
00443                    const char *cname2,
00444                    double begin2, double end2, double stride2,
00445                    const char *cname3,
00446                    double begin3, double end3, double stride3,
00447                    const char *wtname,
00448                    std::vector<double> &weights,
00449                    std::vector<ibis::bitvector*> &bins) const;
00452     long get1DBins(const char *constraints, const char *cname1, uint32_t nb1,
00453                    std::vector<double> &bounds1,
00454                    std::vector<ibis::bitvector> &bins) const;
00456     long get2DBins(const char *constraints,
00457                    const char *cname1, const char *cname2,
00458                    uint32_t nb1, uint32_t nb2,
00459                    std::vector<double> &bounds1,
00460                    std::vector<double> &bounds2,
00461                    std::vector<ibis::bitvector> &bins) const;
00463     long get3DBins(const char *constraints,
00464                    const char *cname1, const char *cname2, const char *cname3,
00465                    uint32_t nb1, uint32_t nb2, uint32_t nb3,
00466                    std::vector<double> &bounds1,
00467                    std::vector<double> &bounds2,
00468                    std::vector<double> &bounds3,
00469                    std::vector<ibis::bitvector> &bins) const;
00471 
00476     long getDistribution(const char *name,
00477                          std::vector<double> &bounds,
00478                          std::vector<uint32_t> &counts) const;
00480     long getDistribution(const char *constraints,
00481                          const char *name,
00482                          std::vector<double> &bounds,
00483                          std::vector<uint32_t> &counts) const;
00486     long getDistribution(const char *name, uint32_t nbc,
00487                          double *bounds, uint32_t *counts) const;
00490     long getDistribution(const char *name, const char *constraints,
00491                          uint32_t nbc, double *bounds,
00492                          uint32_t *counts) const;
00493 
00495     long getJointDistribution(const char *constraints,
00496                               const char *name1, const char *name2,
00497                               std::vector<double> &bounds1,
00498                               std::vector<double> &bounds2,
00499                               std::vector<uint32_t> &counts) const;
00500 
00502     long getCumulativeDistribution(const char *name,
00503                                    std::vector<double> &bounds,
00504                                    std::vector<uint32_t> &counts) const;
00507     long getCumulativeDistribution(const char *constraints,
00508                                    const char *name,
00509                                    std::vector<double> &bounds,
00510                                    std::vector<uint32_t> &counts) const;
00513     long getCumulativeDistribution(const char *name, uint32_t nbc,
00514                                    double *bounds, uint32_t *counts) const;
00517     long getCumulativeDistribution(const char *constraints, const char *name,
00518                                    uint32_t nbc, double *bounds,
00519                                    uint32_t *counts) const;
00521 
00522     /******************************************************************/
00533     const std::vector<uint32_t> &getMeshShape() const {return shapeSize;}
00536     const std::vector<std::string> &getMeshDimensions() const {
00537         return shapeName;}
00541     void setMeshShape(const char *shape) {
00542         digestMeshShape(shape);
00543         writeMetaData(nEvents, columns, activeDir);
00544     }
00546     void updateMetaData() const {writeMetaData(nEvents, columns, activeDir);}
00548     void combineNames(ibis::table::namesTypes &metalist) const;
00549 
00550     /******************************************************************/
00552     long append(const char* dir);
00557     long commit(const char* dir);
00560     long rollback();
00562     long addColumn(const char* aexpr, const char* cname,
00563                    ibis::TYPE_T ctype=ibis::DOUBLE);
00565     long addColumn(const ibis::math::term* xpr, ibis::bitvector& mask,
00566                    const char* cname, ibis::TYPE_T ctype=ibis::DOUBLE);
00567 
00568     /******************************************************************/
00570     long reorder();
00572     long reorder(const ibis::table::stringList &names);
00573 
00575     long deactivate(const std::vector<uint32_t> &rows);
00577     long deactivate(const char* conds);
00580     long reactivate(const std::vector<uint32_t> &rows);
00582     long reactivate(const char* conds);
00584     long purgeInactive();
00586     void emptyCache() const;
00588     const ibis::bitvector &getNullMask() const {return amask;}
00589 
00591     static char* readMetaTags(const char* const dir);
00593     static void  genName(const std::vector<const char*> &mtags,
00594                          std::string &name);
00596     static void  genName(const ibis::resource::vList &mtags,
00597                          std::string &name);
00599     static uint32_t countPages(const ibis::bitvector &mask,
00600                                unsigned elemsize=4);
00602     ibis::fileManager::ACCESS_PREFERENCE
00603     accessHint(const ibis::bitvector &mask, unsigned elemsize=4) const;
00604 
00606     struct thrArg {
00607         const part* et;
00608         const char* pref;
00609         long* nerrors;  
00610         ibis::util::counter cnt;
00611         std::vector<std::string> conds; 
00612         std::vector<unsigned> super;
00613         std::vector<unsigned> hits; 
00614     };
00616     struct indexBuilderPool {
00617         ibis::util::counter cnt;
00618         const char* opt;
00619         const part &tbl;
00620         indexBuilderPool(const part &t, const char* spec)
00621             : cnt(), opt(spec), tbl(t) {}
00622     };
00623 
00625     void queryTest(const char* pref, long* nerrors) const;
00627     void quickTest(const char* pref, long* nerrors) const;
00630     void testRangeOperators(const char* pref, const ibis::column* col,
00631                             long* nerrors) const;
00632 
00633     // These functions are in used classes barrel and vault
00634     void logWarning(const char* event, const char* fmt, ...) const;
00635     void logMessage(const char* event, const char* fmt, ...) const;
00636 
00637     void doBackup(); 
00638 
00639     class barrel;
00640     class vault;
00642     typedef std::map< const char*, column*, lessi > columnList;
00643 
00644 protected:
00645     class cleaner;      
00646     class writeLock;    
00647     class advisoryLock; 
00648 
00649     friend struct info;
00650     friend class cleaner;
00651     friend class readLock;
00652     friend class writeLock;
00653     friend class advisoryLock;
00654 
00655     /******************************************************************/
00656     // protected member variables
00657     //
00658     char* m_name;               
00659     std::string m_desc;         
00660     ibis::resource::vList metaList;     
00661     mutable array_t<rid_t>* rids;       
00662     columnList columns;         
00663     uint32_t nEvents;           
00664     char* activeDir;            
00665     char* backupDir;            
00666     time_t switchTime;          
00667     TABLE_STATE state;
00668     char* idxstr;               
00669 
00670     ibis::bitvector amask;      
00671     std::vector<const column*> colorder;
00672     std::vector<std::string> shapeName; 
00673     std::vector<uint32_t> shapeSize;    
00674 
00675     ibis::part::cleaner* myCleaner;     
00676 
00677 
00678     /******************************************************************/
00679     // protected member functions
00680     //
00682     int  readMetaData(uint32_t &nrows, columnList &plist, const char* dir);
00684     void writeMetaData(const uint32_t nrows, const columnList &plist,
00685                        const char* dir) const;
00686     void readRIDs() const; 
00687     void freeRIDs() const; 
00688 
00689     // functions to deal with meta tags -- those attributes that are set of
00690     // a whole partition but are expected to be processed like a categorical
00691     // attribute in queries
00692     void extendMetaTags();
00693     void setMetaTags(const ibis::resource::vList &mts);
00694     void setMetaTags(const std::vector<const char*> &mts);
00695 
00697     void readMeshShape(const char* const dir);
00699     void digestMeshShape(const char* shape);
00700 
00702     void logError(const char* event, const char* fmt, ...) const;
00703 
00704     void makeBackupCopy(); // copy the content of activeDir to backupDir
00705     long verifyBackupDir(); // minimal consistency check
00706     void deriveBackupDirName();
00707     long appendToBackup(const char* dir); // append to the backup directory
00708 
00710     template <typename T>
00711     long writeValues(const char *fname, const array_t<uint32_t> &ind);
00713     template <typename T>
00714     long reorderValues(const char *fname, const array_t<uint32_t> &indin,
00715                        array_t<uint32_t> &indout, array_t<uint32_t> &starts);
00716     long append1(const char* dir);
00717     long append2(const char* dir);
00718 
00720     long deactivate(const ibis::bitvector &rows);
00722     long reactivate(const ibis::bitvector &rows);
00724     void numbersToBitvector(const std::vector<uint32_t>&,
00725                             ibis::bitvector&) const;
00726     void stringToBitvector(const char*, ibis::bitvector&) const;
00727 
00730     template <typename T>
00731     long doCompare(const array_t<T> &array,
00732                    const ibis::bitvector &mask,
00733                    ibis::bitvector &hits,
00734                    const ibis::qRange &cmp) const;
00735 
00739     template <typename T>
00740     long negativeCompare(const array_t<T> &array,
00741                          const ibis::bitvector &mask,
00742                          ibis::bitvector &hits,
00743                          const ibis::qRange &cmp) const;
00746     template <typename T>
00747     long doCompare(const char *file,
00748                    const ibis::bitvector &mask,
00749                    ibis::bitvector &hits,
00750                    const ibis::qRange &cmp) const;
00754     template <typename T>
00755     long negativeCompare(const char *file,
00756                          const ibis::bitvector &mask,
00757                          ibis::bitvector &hits,
00758                          const ibis::qRange &cmp) const;
00759 
00762     template <typename T, typename F>
00763         static long doCompare(const array_t<T> &vals, F cmp,
00764                               const ibis::bitvector &mask,
00765                               ibis::bitvector &hits);
00766 
00769     template <typename T, typename F>
00770         static long doCompare0(const array_t<T> &vals, F cmp,
00771                                const ibis::bitvector &mask,
00772                                ibis::bitvector &hits);
00773 
00776     template <typename T, typename F1, typename F2>
00777         static long doCompare(const array_t<T> &vals, F1 cmp1, F2 cmp2,
00778                               const ibis::bitvector &mask,
00779                               ibis::bitvector &hits);
00780 
00783     template <typename T, typename F1, typename F2>
00784         static long doCompare0(const array_t<T> &vals, F1 cmp1, F2 cmp2,
00785                                const ibis::bitvector &mask,
00786                                ibis::bitvector &hits);
00787 
00789     template <typename T>
00790         long doCount(const ibis::qRange &cmp) const;
00791 
00794     template <typename T>
00795         long doCount(const array_t<T> &vals, const ibis::qRange &cmp,
00796                      const ibis::bitvector &mask) const;
00797 
00799     template <typename T, typename F>
00800     long doCount(const array_t<T> &vals,
00801                  const ibis::bitvector &mask, F cmp) const;
00802 
00804     template <typename T, typename F1, typename F2>
00805     long doCount(const array_t<T> &vals,
00806                  const ibis::bitvector &mask, F1 cmp1, F2 cmp2) const;
00807 
00810     long packCumulativeDistribution(const std::vector<double> &bounds,
00811                                     const std::vector<uint32_t> &counts,
00812                                     uint32_t nbc,
00813                                     double *bptr, uint32_t *cptr) const;
00815     long packDistribution(const std::vector<double> &bounds,
00816                           const std::vector<uint32_t> &counts,
00817                           uint32_t nbc, double *bptr, uint32_t *cptr) const;
00818 
00820     template <typename T1, typename T2>
00821     long count2DBins(array_t<T1> &vals1,
00822                      const double &begin1, const double &end1,
00823                      const double &stride1,
00824                      array_t<T2> &vals2,
00825                      const double &begin2, const double &end2,
00826                      const double &stride2,
00827                      std::vector<uint32_t> &counts) const;
00829     template <typename T1, typename T2, typename T3>
00830     long count3DBins(const array_t<T1> &vals1,
00831                      const double &begin1, const double &end1,
00832                      const double &stride1,
00833                      const array_t<T2> &vals2,
00834                      const double &begin2, const double &end2,
00835                      const double &stride2,
00836                      const array_t<T3> &vals3,
00837                      const double &begin3, const double &end3,
00838                      const double &stride3,
00839                      std::vector<uint32_t> &counts) const;
00841     template <typename T1, typename T2>
00842     long count2DWeights(array_t<T1> &vals1,
00843                         const double &begin1, const double &end1,
00844                         const double &stride1,
00845                         array_t<T2> &vals2,
00846                         const double &begin2, const double &end2,
00847                         const double &stride2,
00848                         array_t<double> &wts,
00849                         std::vector<double> &weights) const;
00851     template <typename T1, typename T2, typename T3>
00852     long count3DWeights(const array_t<T1> &vals1,
00853                         const double &begin1, const double &end1,
00854                         const double &stride1,
00855                         const array_t<T2> &vals2,
00856                         const double &begin2, const double &end2,
00857                         const double &stride2,
00858                         const array_t<T3> &vals3,
00859                         const double &begin3, const double &end3,
00860                         const double &stride3,
00861                         const array_t<double> &wts,
00862                         std::vector<double> &weights) const;
00863 
00865     template <typename T1>
00866     long fill1DBins(const ibis::bitvector &mask, const array_t<T1> &vals1,
00867                     const double &begin1, const double &end1,
00868                     const double &stride1,
00869                     std::vector<ibis::bitvector> &bins) const;
00871     template <typename T1>
00872     long fill1DBins(const ibis::bitvector &mask, const array_t<T1> &vals1,
00873                     const double &begin1, const double &end1,
00874                     const double &stride1,
00875                     std::vector<ibis::bitvector*> &bins) const;
00877     template <typename T1>
00878     long fill1DBinsWeighted(const ibis::bitvector &mask,
00879                             const array_t<T1> &vals1,
00880                             const double &begin1, const double &end1,
00881                             const double &stride1,
00882                             const array_t<double> &wts,
00883                             std::vector<double> &weights,
00884                             std::vector<ibis::bitvector*> &bins) const;
00886     template <typename T1, typename T2>
00887     long fill2DBins(const ibis::bitvector &mask, const array_t<T1> &vals1,
00888                     const double &begin1, const double &end1,
00889                     const double &stride1,
00890                     const array_t<T2> &vals2,
00891                     const double &begin2, const double &end2,
00892                     const double &stride2,
00893                     std::vector<ibis::bitvector> &bins) const;
00894     template <typename T1>
00895     long fill2DBins2(const ibis::bitvector &mask, const array_t<T1> &vals1,
00896                      const double &begin1, const double &end1,
00897                      const double &stride1,
00898                      const ibis::column &col2,
00899                      const double &begin2, const double &end2,
00900                      const double &stride2,
00901                      std::vector<ibis::bitvector> &bins) const;
00903     template <typename T1, typename T2>
00904     long fill2DBins(const ibis::bitvector &mask, const array_t<T1> &vals1,
00905                     const double &begin1, const double &end1,
00906                     const double &stride1,
00907                     const array_t<T2> &vals2,
00908                     const double &begin2, const double &end2,
00909                     const double &stride2,
00910                     std::vector<ibis::bitvector*> &bins) const;
00911     template <typename T1>
00912     long fill2DBins2(const ibis::bitvector &mask, const array_t<T1> &vals1,
00913                      const double &begin1, const double &end1,
00914                      const double &stride1,
00915                      const ibis::column &col2,
00916                      const double &begin2, const double &end2,
00917                      const double &stride2,
00918                      std::vector<ibis::bitvector*> &bins) const;
00920     template <typename T1, typename T2>
00921     long fill2DBinsWeighted(const ibis::bitvector &mask,
00922                             const array_t<T1> &vals1,
00923                             const double &begin1, const double &end1,
00924                             const double &stride1,
00925                             const array_t<T2> &vals2,
00926                             const double &begin2, const double &end2,
00927                             const double &stride2,
00928                             const array_t<double> &wts,
00929                             std::vector<double> &weights,
00930                             std::vector<ibis::bitvector*> &bins) const;
00931     template <typename T1>
00932     long fill2DBinsWeighted2(const ibis::bitvector &mask,
00933                              const array_t<T1> &vals1,
00934                              const double &begin1, const double &end1,
00935                              const double &stride1,
00936                              const ibis::column &col2,
00937                              const double &begin2, const double &end2,
00938                              const double &stride2,
00939                              const array_t<double> &wts,
00940                              std::vector<double> &weights,
00941                              std::vector<ibis::bitvector*> &bins) const;
00943     template <typename T1, typename T2, typename T3>
00944     long fill3DBins(const ibis::bitvector &mask, const array_t<T1> &vals1,
00945                     const double &begin1, const double &end1,
00946                     const double &stride1,
00947                     const array_t<T2> &vals2,
00948                     const double &begin2, const double &end2,
00949                     const double &stride2,
00950                     const array_t<T3> &vals3,
00951                     const double &begin3, const double &end3,
00952                     const double &stride3,
00953                     std::vector<ibis::bitvector> &bins) const;
00954     template <typename T1>
00955     long fill3DBins2(const ibis::bitvector &mask, const array_t<T1> &vals1,
00956                      const double &begin1, const double &end1,
00957                      const double &stride1,
00958                      const ibis::column &col2,
00959                      const double &begin2, const double &end2,
00960                      const double &stride2,
00961                      const ibis::column &col3,
00962                      const double &begin3, const double &end3,
00963                      const double &stride3,
00964                      std::vector<bitvector> &bins) const;
00965     template <typename T1, typename T2>
00966     long fill3DBins3(const ibis::bitvector &mask, const array_t<T1> &vals1,
00967                      const double &begin1, const double &end1,
00968                      const double &stride1,
00969                      const array_t<T2> &vals2,
00970                      const double &begin2, const double &end2,
00971                      const double &stride2,
00972                      const ibis::column &col3,
00973                      const double &begin3, const double &end3,
00974                      const double &stride3,
00975                      std::vector<bitvector> &bins) const;
00976     template <typename T1, typename T2, typename T3>
00977     long fill3DBins(const ibis::bitvector &mask, const array_t<T1> &vals1,
00978                     const double &begin1, const double &end1,
00979                     const double &stride1,
00980                     const array_t<T2> &vals2,
00981                     const double &begin2, const double &end2,
00982                     const double &stride2,
00983                     const array_t<T3> &vals3,
00984                     const double &begin3, const double &end3,
00985                     const double &stride3,
00986                     std::vector<bitvector*> &bins) const;
00987     template <typename T1>
00988     long fill3DBins2(const ibis::bitvector &mask, const array_t<T1> &vals1,
00989                      const double &begin1, const double &end1,
00990                      const double &stride1,
00991                      const ibis::column &col2,
00992                      const double &begin2, const double &end2,
00993                      const double &stride2,
00994                      const ibis::column &col3,
00995                      const double &begin3, const double &end3,
00996                      const double &stride3,
00997                      std::vector<ibis::bitvector*> &bins) const;
00998     template <typename T1, typename T2>
00999     long fill3DBins3(const ibis::bitvector &mask, const array_t<T1> &vals1,
01000                      const double &begin1, const double &end1,
01001                      const double &stride1,
01002                      const array_t<T2> &vals2,
01003                      const double &begin2, const double &end2,
01004                      const double &stride2,
01005                      const ibis::column &col3,
01006                      const double &begin3, const double &end3,
01007                      const double &stride3,
01008                      std::vector<ibis::bitvector*> &bins) const;
01009     template <typename T1, typename T2, typename T3>
01010     long fill3DBinsWeighted(const ibis::bitvector &mask,
01011                             const array_t<T1> &vals1,
01012                             const double &begin1, const double &end1,
01013                             const double &stride1,
01014                             const array_t<T2> &vals2,
01015                             const double &begin2, const double &end2,
01016                             const double &stride2,
01017                             const array_t<T3> &vals3,
01018                             const double &begin3, const double &end3,
01019                             const double &stride3,
01020                             const array_t<double> &wts,
01021                             std::vector<double> &weights,
01022                             std::vector<bitvector*> &bins) const;
01023     template <typename T1>
01024     long fill3DBinsWeighted2(const ibis::bitvector &mask,
01025                              const array_t<T1> &vals1,
01026                              const double &begin1, const double &end1,
01027                              const double &stride1,
01028                              const ibis::column &col2,
01029                              const double &begin2, const double &end2,
01030                              const double &stride2,
01031                              const ibis::column &col3,
01032                              const double &begin3, const double &end3,
01033                              const double &stride3,
01034                              const array_t<double> &wts,
01035                              std::vector<double> &weights,
01036                              std::vector<ibis::bitvector*> &bins) const;
01037     template <typename T1, typename T2>
01038     long fill3DBinsWeighted3(const ibis::bitvector &mask,
01039                              const array_t<T1> &vals1,
01040                              const double &begin1, const double &end1,
01041                              const double &stride1,
01042                              const array_t<T2> &vals2,
01043                              const double &begin2, const double &end2,
01044                              const double &stride2,
01045                              const ibis::column &col3,
01046                              const double &begin3, const double &end3,
01047                              const double &stride3,
01048                              const array_t<double> &wts,
01049                              std::vector<double> &weights,
01050                              std::vector<ibis::bitvector*> &bins) const;
01051 
01053     long get1DBins_(const ibis::bitvector &mask, const ibis::column &col,
01054                     uint32_t nbin, std::vector<double> &bounds,
01055                     std::vector<ibis::bitvector> &bins, const char *mesg) const;
01056 
01058     long get1DDistribution(const ibis::column &col, uint32_t nbin,
01059                            std::vector<double> &bounds,
01060                            std::vector<uint32_t> &counts) const;
01062     long get2DDistributionU(const ibis::column &col1,
01063                             const ibis::column &col2,
01064                             uint32_t nb1, uint32_t nb2,
01065                             std::vector<double> &bounds1,
01066                             std::vector<double> &bounds2,
01067                             std::vector<uint32_t> &counts) const;
01069     long get2DDistributionA(const ibis::column &col1,
01070                             const ibis::column &col2,
01071                             uint32_t nb1, uint32_t nb2,
01072                             std::vector<double> &bounds1,
01073                             std::vector<double> &bounds2,
01074                             std::vector<uint32_t> &counts) const;
01076     long get2DDistributionI(const ibis::column &col1,
01077                             const ibis::column &col2,
01078                             uint32_t nb1, uint32_t nb2,
01079                             std::vector<double> &bounds1,
01080                             std::vector<double> &bounds2,
01081                             std::vector<uint32_t> &counts) const;
01082     long old2DDistribution(const char *constraints,
01083                            const char *name1, const char *name2,
01084                            uint32_t nb1, uint32_t nb2,
01085                            std::vector<double> &bounds1,
01086                            std::vector<double> &bounds2,
01087                            std::vector<uint32_t> &counts) const;
01089     int coarsenBins(const ibis::column &col, uint32_t nbin,
01090                     std::vector<double> &bnds,
01091                     std::vector<ibis::bitvector*> &btmp) const;
01093     long get3DDistributionA(const ibis::bitvector &mask,
01094                             const ibis::column &col1,
01095                             const ibis::column &col2,
01096                             const ibis::column &col3,
01097                             uint32_t nb1, uint32_t nb2, uint32_t nb3,
01098                             std::vector<double> &bounds1,
01099                             std::vector<double> &bounds2,
01100                             std::vector<double> &bounds3,
01101                             std::vector<uint32_t> &counts) const;
01102     template <typename E1>
01103     long get3DDistributionA1(const ibis::bitvector &mask,
01104                              const array_t<E1> &vals1,
01105                              const ibis::column &col2,
01106                              const ibis::column &col3,
01107                              uint32_t nb1, uint32_t nb2, uint32_t nb3,
01108                              std::vector<double> &bounds1,
01109                              std::vector<double> &bounds2,
01110                              std::vector<double> &bounds3,
01111                              std::vector<uint32_t> &counts) const;
01112     template <typename E1, typename E2>
01113     long get3DDistributionA2(const ibis::bitvector &mask,
01114                              const array_t<E1> &vals1,
01115                              const array_t<E2> &vals2,
01116                              const ibis::column &col3,
01117                              uint32_t nb1, uint32_t nb2, uint32_t nb3,
01118                              std::vector<double> &bounds1,
01119                              std::vector<double> &bounds2,
01120                              std::vector<double> &bounds3,
01121                              std::vector<uint32_t> &counts) const;
01122 
01123     template <typename E1, typename E2>
01124         static void mapValues(array_t<E1> &val1, array_t<E2> &val2,
01125                               uint32_t nb1, uint32_t nb2,
01126                               array_t<E1> &bnd1, array_t<E2> &bnd2,
01127                               std::vector<uint32_t> &cnts);
01128 
01129     template <typename T>
01130         static void mapValues(const array_t<T> &vals,
01131                               std::map<T, uint32_t> &hist);
01132 
01133     template <typename T>
01134         static void equalWeightBins(const array_t<T> &vals,
01135                                     uint32_t nbins, array_t<T> &bounds);
01136 
01137     template <typename T>
01138         static long adaptiveInts(const array_t<T> &vals, const T vmin,
01139                                  const T vmax, uint32_t nbins,
01140                                  std::vector<double> &bounds,
01141                                  std::vector<uint32_t> &counts);
01142 
01143     template <typename T>
01144         static long adaptiveFloats(const array_t<T> &vals, const T vmin,
01145                                    const T vmax, uint32_t nbins,
01146                                    std::vector<double> &bounds,
01147                                    std::vector<uint32_t> &counts);
01148 
01149     template <typename T1, typename T2>
01150         static long adaptive2DBins(const array_t<T1> &vals1,
01151                                    const array_t<T2> &vals2,
01152                                    uint32_t nb1, uint32_t nb2,
01153                                    std::vector<double> &bounds1,
01154                                    std::vector<double> &bounds2,
01155                                    std::vector<uint32_t> &counts);
01156 
01157     template <typename T1, typename T2, typename T3>
01158         static long adaptive3DBins(const array_t<T1> &vals1,
01159                                    const array_t<T2> &vals2,
01160                                    const array_t<T3> &vals3,
01161                                    uint32_t nb1, uint32_t nb2, uint32_t nb3,
01162                                    std::vector<double> &bounds1,
01163                                    std::vector<double> &bounds2,
01164                                    std::vector<double> &bounds3,
01165                                    std::vector<uint32_t> &counts);
01166 
01167     template <typename T> static long
01168         adaptiveIntsDetailed(const ibis::bitvector &mask,
01169                              const array_t<T> &vals,
01170                              const T vmin, const T vmax, uint32_t nbins,
01171                              std::vector<double> &bounds,
01172                              std::vector<ibis::bitvector> &detail);
01173 
01174     template <typename T> static long
01175         adaptiveFloatsDetailed(const ibis::bitvector &mask,
01176                                const array_t<T> &vals,
01177                                const T vmin, const T vmax, uint32_t nbins,
01178                                std::vector<double> &bounds,
01179                                std::vector<ibis::bitvector> &detail);
01180 
01181     void composeQueryString(std::string &str,
01182                             const ibis::column* col1, const ibis::column* col2,
01183                             const double &lower1, const double &upper1,
01184                             const double &lower2, const double &upper2) const;
01185     void buildQueryList(ibis::part::thrArg &lst,
01186                         unsigned nc, unsigned nq) const;
01187     void checkQueryList(const ibis::part::thrArg &lst) const;
01188 
01189 private:
01190 
01191     /******************************************************************/
01192     // private member variables
01193     mutable pthread_mutex_t mutex;      //< Mutex for partition manipulation.
01194     mutable pthread_rwlock_t rwlock;    //< Rwlock for access control.
01195 
01196     /******************************************************************/
01197     // private funcations
01198 
01199     void init(const char* prefix); 
01200 
01201     inline void gainReadAccess(const char* mesg) const;
01202     inline void releaseAccess(const char* mesg) const;
01203     inline void gainWriteAccess(const char* mesg) const;
01204     uint32_t recursiveQuery(const char* pref, const column* att,
01205                             double low, double high, long* nerr) const;
01206 
01207     void   fillRIDs(const char* fn) const; 
01208     void   sortRIDs() const; 
01209     uint32_t searchSortedRIDs(const ibis::rid_t &rid) const;
01210     uint32_t searchRIDs(const ibis::rid_t &rid) const;
01211     void   searchSortedRIDs(const ibis::RIDSet&, ibis::bitvector&) const;
01212     void   searchRIDs(const ibis::RIDSet&, ibis::bitvector&) const;
01213 
01214     // functions to perform join operations.
01215     int64_t equiJoin(const ibis::rangeJoin &cmp,
01216                      const ibis::bitvector64 &trial,
01217                      ibis::bitvector64 &result) const;
01218     int64_t rangeJoin(const ibis::rangeJoin &cmp,
01219                       const ibis::bitvector64 &trial,
01220                       ibis::bitvector64 &result) const;
01221     int64_t compJoin(const ibis::rangeJoin &cmp,
01222                      const ibis::bitvector64 &trial,
01223                      ibis::bitvector64 &result) const;
01224 
01225     int64_t loopJoin(const std::vector<const ibis::rangeJoin*> &cmp,
01226                      const ibis::bitvector &mask,
01227                      ibis::bitvector64 &pairs) const;
01228     int64_t loopJoin(const std::vector<const ibis::rangeJoin*> &cmp,
01229                      const ibis::bitvector &mask) const;
01230     int64_t loopJoin(const ibis::rangeJoin &cmp,
01231                      const ibis::bitvector &mask,
01232                      ibis::bitvector64 &pairs) const;
01233     int64_t loopJoin(const ibis::rangeJoin &cmp,
01234                      const ibis::bitvector &mask) const;
01235     int64_t equiJoinLoop1(const ibis::rangeJoin &cmp,
01236                           const ibis::bitvector &mask,
01237                           ibis::bitvector64 &pairs) const;
01238     int64_t equiJoinLoop1(const ibis::rangeJoin &cmp,
01239                           const ibis::bitvector &mask) const;
01240     int64_t equiJoinLoop2(const ibis::rangeJoin &cmp,
01241                           const ibis::bitvector &mask,
01242                           ibis::bitvector64 &pairs) const;
01243     int64_t equiJoinLoop2(const ibis::rangeJoin &cmp,
01244                           const ibis::bitvector &mask) const;
01245     template <class type1, class type2>
01246     void rangeJoinLoop(const array_t<type1> &arr1,
01247                        const ibis::bitvector &msk1,
01248                        const array_t<type2> &arr2,
01249                        const ibis::bitvector &msk2,
01250                        const double delta,
01251                        ibis::bitvector64 &pairs) const;
01252     template <class type1, class type2>
01253     int64_t rangeJoinLoop(const array_t<type1> &arr1,
01254                           const ibis::bitvector &msk1,
01255                           const array_t<type2> &arr2,
01256                           const ibis::bitvector &msk2,
01257                           const double delta) const;
01258     int64_t rangeJoinLoop(const ibis::rangeJoin &cmp,
01259                           const ibis::bitvector &mask,
01260                           ibis::bitvector64 &pairs) const;
01261     int64_t rangeJoinLoop(const ibis::rangeJoin &cmp,
01262                           const ibis::bitvector &mask) const;
01263     int64_t compJoinLoop(const ibis::rangeJoin &cmp,
01264                          const ibis::bitvector &mask,
01265                          ibis::bitvector64 &pairs) const;
01266     int64_t compJoinLoop(const ibis::rangeJoin &cmp,
01267                          const ibis::bitvector &mask) const;
01268 
01269     part(const part&);
01270     const part &operator=(const part&);
01271 }; // class ibis::part
01272 
01273 namespace ibis {
01274     // Extends the name space ibis::util to contain three more functions to
01275     // deal with the reconstruction of partitions.
01276     namespace util {
01278         unsigned int FASTBIT_CXX_DLLSPEC
01279         tablesFromDir(ibis::partList &parts,
01280                       const char *adir, const char *bdir);
01282         unsigned int FASTBIT_CXX_DLLSPEC
01283         tablesFromDir(ibis::partList &parts, const char *adir);
01286         unsigned int FASTBIT_CXX_DLLSPEC
01287         tablesFromResources(ibis::partList &parts, const ibis::resource &res);
01288     } // namespace util
01289 } // namespace ibis
01290 
01294 struct FASTBIT_CXX_DLLSPEC ibis::part::info {
01295     const char* name;           
01296     const char* description;    
01297     const char* metaTags;       
01298     const uint64_t nrows;       
01299 
01300     std::vector<ibis::column::info*> cols;
01301 
01302     info(const char* na, const char* de, const uint64_t &nr,
01303          const ibis::part::columnList &co);
01304     info(const ibis::part &tbl);
01305     ~info();
01306 
01307 private:
01308     info();     // private default constructor, not implemented!
01309 }; // ibis::part::info
01310 
01312 class ibis::part::cleaner : public ibis::fileManager::cleaner {
01313 public:
01314     virtual void operator()() const;
01315     cleaner(const part* tbl) : thePart(tbl) {}
01316     virtual ~cleaner() {}
01317 
01318 private:
01319     const part* thePart;
01320 }; // ibis::part::cleaner
01321 
01326 class ibis::part::readLock {
01327 public:
01328     readLock(const part* tbl, const char* m) : thePart(tbl), mesg(m) {
01329         tbl->gainReadAccess(m);
01330     }
01331     ~readLock() {thePart->releaseAccess(mesg);}
01332 
01333 private:
01334     const part* thePart;
01335     const char* mesg;
01336 
01337     readLock() {}; // no default constructor
01338     readLock(const readLock&) {}; // can not copy
01339     const readLock &operator=(const readLock&);
01340 }; // ibis::part::readLock
01341 
01343 class ibis::part::writeLock {
01344 public:
01345     writeLock(const part* tbl, const char* m) : thePart(tbl), mesg(m) {
01346         tbl->gainWriteAccess(m);
01347     }
01348     ~writeLock() {thePart->releaseAccess(mesg);}
01349 
01350 private:
01351     const part* thePart;
01352     const char* mesg;
01353 
01354     writeLock() {}; // no default constructor
01355     writeLock(const writeLock&) {}; // can not copy
01356     const writeLock &operator=(const writeLock&);
01357 }; // ibis::part::writeLock
01358 
01362 class ibis::part::advisoryLock {
01363 public:
01365     advisoryLock(const part* tbl, const char* m)
01366         : thePart(tbl), mesg(m),
01367           locked(pthread_rwlock_trywrlock(&(tbl->rwlock))) {
01368         if (ibis::gVerbose > 9)
01369             thePart->logMessage("gainWriteAccess", "%s write access for %s",
01370                                  (locked==0?"acquired":"could not acquire"),
01371                                  mesg);
01372     }
01374     ~advisoryLock() {if (locked==0) thePart->releaseAccess(mesg);}
01377     bool acquired() const {return (locked==0);}
01378 
01379 private:
01380     const part* thePart;
01381     const char* mesg;
01382     const int locked;
01383 
01384     advisoryLock() : thePart(0), mesg(0), locked(0) {};
01385     advisoryLock(const advisoryLock &rhs)
01386         : thePart(rhs.thePart), mesg(rhs.mesg), locked(0) {};
01387     const advisoryLock &operator=(const advisoryLock&);
01388 }; // ibis::part::advisoryLock
01389 
01393 class ibis::part::barrel : public ibis::math::barrel {
01394 public:
01395     barrel(const ibis::part *t=0) : _tbl(t), position(0) {};
01396     virtual ~barrel() {close();} 
01397 
01398     virtual long open(const ibis::part *t=0); 
01399     virtual long close(); 
01400     virtual long read(); 
01401 
01402 
01403     virtual long seek(uint32_t pos);
01404     uint32_t tell() const {return position;}
01405 
01406     void getNullMask(ibis::bitvector &mask) const;
01407     const ibis::column* getColumn(uint32_t i) const {return cols[i];}
01408 
01409 protected:
01410     const ibis::part *_tbl;
01411     uint32_t position;
01412     std::vector<const ibis::column*> cols;
01413     std::vector<ibis::fileManager::storage*> stores;
01414     std::vector<int> fdes;
01415 }; // ibis::part::barrel
01416 
01419 class ibis::part::vault : public ibis::part::barrel {
01420 public:
01421     vault(const ibis::roster &r);
01422     virtual ~vault() {close();}
01423 
01424     virtual long open(const ibis::part *t=0); 
01425     virtual long read(); 
01426     virtual long seek(uint32_t pos); 
01427 
01428     long seek(double val);
01431     uint32_t tellReal() const;
01432 
01433 private:
01434     const ibis::roster &_roster;
01435 
01436     template <class T>
01437     uint32_t seekValue(int fd, const T &val) const;
01438     template <class T>
01439     uint32_t seekValue(const array_t<T>&arr, const T &val) const;
01440 }; // ibis::part::vault
01441 /*
01442 barrel
01443 
01444 Vault \Vault\ (v[add]lt; see Note, below), n. [OE. voute, OF. voute, volte,
01445 F. vo[^u]te, LL. volta, for voluta, volutio, fr. L. volvere, volutum, to
01446 roll, to turn about. See Voluble, and cf. Vault a leap, Volt a turn,
01447 Volute.] 1. (Arch.) An arched structure of masonry, forming a ceiling or
01448 canopy.
01449 
01450 The long-drawn aisle and fretted vault. --Gray.
01451 
01452 2. An arched apartment; especially, a subterranean room, use for storing
01453    articles, for a prison, for interment, or the like; a cell; a
01454    cellar. ``Charnel vaults.'' --Milton.
01455 
01456 The silent vaults of death. --Sandys.
01457 
01458 To banish rats that haunt our vault. --Swift.
01459 
01460 3. The canopy of heaven; the sky.
01461 
01462 That heaven's vault should crack. --Shak.
01463 
01464 4. [F. volte, It. volta, originally, a turn, and the same word as volta an
01465    arch. See the Etymology above.] A leap or bound. Specifically: (a)
01466    (Man.) The bound or leap of a horse; a curvet. (b) A leap by aid of the
01467    hands, or of a pole, springboard, or the like.
01468 
01469 Note: The l in this word was formerly often suppressed in pronunciation.
01470 
01471 Barrel, Cradle, Cylindrical, or Wagon, vault (Arch.), a kind of vault
01472 having two parallel abutments, and the same section or profile at all
01473 points. It may be rampant, as over a staircase (see Rampant vault, under
01474 Rampant), or curved in plan, as around the apse of a church.
01475 
01476 Coved vault. (Arch.) See under 1st Cove, v. t.
01477 
01478 Groined vault (Arch.), a vault having groins, that is, one in which
01479 different cylindrical surfaces intersect one another, as distinguished from
01480 a barrel, or wagon, vault.
01481 
01482 Rampant vault. (Arch.) See under Rampant.
01483 
01484 Ribbed vault (Arch.), a vault differing from others in having solid ribs
01485 which bear the weight of the vaulted surface. True Gothic vaults are of
01486 this character.
01487 
01488 Vault light, a partly glazed plate inserted in a pavement or ceiling to
01489 admit light to a vault below.
01490 
01491 Source: Webster's Revised Unabridged Dictionary, (c) 1996, 1998 MICRA, Inc.
01492  */
01493 
01494 namespace ibis {
01495     // Explicit template specialization for member function
01496     // ibis::part::equalWeightBins
01497     template <> void
01498     part::equalWeightBins(const array_t<float> &vals,
01499                           uint32_t nbins, array_t<float> &bounds);
01500     template <> void
01501     part::equalWeightBins(const array_t<double> &vals,
01502                           uint32_t nbins, array_t<double> &bounds);
01503 
01504     template <> long
01505     part::doScan(const array_t<float> &,
01506                  const ibis::qContinuousRange &,
01507                  const ibis::bitvector &, ibis::bitvector &);
01508     template <> long
01509     part::doScan(const array_t<double> &,
01510                  const ibis::qContinuousRange &,
01511                  const ibis::bitvector &, ibis::bitvector &);
01512 
01513     template <> long
01514     part::doCount<float>(const ibis::qRange&) const;
01515     template <> long
01516     part::doCount<double>(const ibis::qRange&) const;
01517 }
01518 
01520 inline ibis::part::info* ibis::part::getInfo() const {
01521     return new info(*this);
01522 }
01523 
01524 inline void ibis::part::releaseAccess(const char* mesg) const {
01525     if (ibis::gVerbose > 8)
01526         logMessage("releaseAccess", "releasing rwlock for %s", mesg);
01527     int ierr = pthread_rwlock_unlock(&rwlock);
01528     if (0 != ierr) {
01529         logWarning("releaseAccess", "pthread_rwlock_unlock for %s "
01530                    "returned %d (%s)", mesg, ierr, strerror(ierr));
01531     }
01532 } // ibis::part::releaseAccess
01533 
01534 inline void ibis::part::gainReadAccess(const char* mesg) const {
01535     if (ibis::gVerbose > 8)
01536         logMessage("gainReadAccess", "acquiring read lock for %s", mesg);
01537     int ierr = pthread_rwlock_rdlock(&rwlock);
01538     if (0 != ierr) {
01539         logWarning("gainReadAccess", "pthread_rwlock_rdlock for %s "
01540                    "returned %d (%s)", mesg, ierr, strerror(ierr));
01541     }
01542 } // ibis::part::gainReadAccess
01543 
01544 inline void ibis::part::gainWriteAccess(const char* mesg) const {
01545     if (ibis::gVerbose > 8)
01546         logMessage("gainWriteAccess", "acquiring write lock for %s", mesg);
01547     int ierr = pthread_rwlock_wrlock(&rwlock);
01548     if (0 != ierr)
01549         logWarning("gainWriteAccess", "pthread_rwlock_wrlock for "
01550                    "%s returned %d (%s)", mesg, ierr, strerror(ierr));
01551 } // ibis::part::gainWriteAccess
01552 
01553 inline ibis::column* ibis::part::getColumn(const char* prop) const {
01554     ibis::column *ret = 0;
01555     columnList::const_iterator it = columns.find(prop);
01556     if (it != columns.end()) {
01557         ret = (*it).second;
01558     }
01559     return ret;
01560 }
01561 
01562 inline ibis::column* ibis::part::getColumn(uint32_t ind) const {
01563     if (ind < columns.size()) {
01564         ibis::part::columnList::const_iterator it = columns.begin();
01565         while (ind > 0) {++it; --ind;}
01566         return (*it).second;
01567     }
01568     else {
01569         return 0;
01570     }
01571 } // getColumn
01572 
01573 inline const char* ibis::part::getMetaTag(const char* name) const {
01574     ibis::resource::vList::const_iterator it = metaList.find(name);
01575     if (it != metaList.end())
01576         return (*it).second;
01577     else
01578         return static_cast<const char*>(0);
01579 } // getMetaTag
01580 
01581 inline int64_t ibis::part::evaluateJoin(const ibis::rangeJoin &cmp,
01582                                         const ibis::bitvector &mask,
01583                                         ibis::bitvector64 &pairs) const {
01584     return loopJoin(cmp, mask, pairs);
01585 } // ibis::part::evaluateJoin
01586 
01587 inline int64_t ibis::part::evaluateJoin(const ibis::rangeJoin &cmp,
01588                                         const ibis::bitvector &mask,
01589                                         const char *pairfile) const {
01590     logWarning("evaluate", "not implemented yet");
01591     return -1;
01592 } // ibis::part::evaluateJoin
01593 
01594 inline int64_t ibis::part::evaluateJoin(const ibis::rangeJoin &cmp,
01595                                         const ibis::bitvector &mask) const {
01596     return loopJoin(cmp, mask);
01597 } // ibis::part::evaluateJoin
01598 
01599 inline int64_t ibis::part::evaluateJoin
01600 (const std::vector<const ibis::rangeJoin*> &cmp,
01601  const ibis::bitvector &mask, ibis::bitvector64 &pairs) const {
01602     return loopJoin(cmp, mask, pairs);
01603 } // ibis::part::evaluateJoin
01604 
01606 inline void ibis::part::cleaner::operator()() const {
01607     const uint32_t sz = ibis::fileManager::bytesInUse();
01608     thePart->unloadIndexes();
01609     if (sz == ibis::fileManager::bytesInUse() &&
01610         thePart->getStateNoLocking() == ibis::part::STABLE_STATE) {
01611         thePart->freeRIDs();
01612     }
01613 } // ibis::part::cleaner::operator
01614 #endif // IBIS_PART_H


	Contact us Disclaimers FastBit source code FastBit mailing list archive