bord.h
Go to the documentation of this file.
00001 // File: $Id$
00002 // Author: John Wu <John.Wu at acm.org>
00003 //      Lawrence Berkeley National Laboratory
00004 // Copyright 2007-2012 the Regents of the University of California
00005 #ifndef IBIS_BORD_H
00006 #define IBIS_BORD_H
00007 #include "table.h"      // ibis::table
00008 #include "util.h"       // ibis::partList
00009 #include "part.h"       // ibis::part
00010 #include "selectClause.h"// ibis::selectClause
00011 
00015 namespace ibis {
00016     class bord;
00017 } // namespace ibis
00018 
00029 class FASTBIT_CXX_DLLSPEC ibis::bord : public ibis::table, public ibis::part {
00030 public:
00031     bord(const char *tn, const char *td, uint64_t nr,
00032          ibis::table::bufferList &buf,
00033          const ibis::table::typeList &ct,
00034          const ibis::table::stringList &cn,
00035          const ibis::table::stringList *cdesc=0,
00036          const std::vector<const ibis::dictionary*> *dct=0);
00037     bord(const char *tn, const char *td,
00038          const ibis::selectClause &sc, const ibis::part &ref);
00039     bord(const char *tn, const char *td,
00040          const ibis::selectClause &sc, const ibis::constPartList &ref);
00041     virtual ~bord() {clear();}
00042 
00043     virtual uint64_t nRows() const {return nEvents;}
00044     virtual uint32_t nColumns() const {return ibis::part::nColumns();}
00045 
00046     virtual ibis::table::stringList columnNames() const;
00047     virtual ibis::table::typeList columnTypes() const;
00048 
00049     virtual void describe(std::ostream&) const;
00050     virtual void dumpNames(std::ostream&, const char*) const;
00051     virtual int dump(std::ostream&, const char*) const;
00052     virtual int dump(std::ostream&, uint64_t, const char*) const;
00053     virtual int dumpJSON(std::ostream&, uint64_t) const;
00054     virtual int dump(std::ostream&, uint64_t, uint64_t, const char*) const;
00055     virtual int backup(const char* dir, const char* tname=0,
00056                        const char* tdesc=0) const;
00057 
00058     virtual int64_t getColumnAsBytes(const char*, char*,
00059                                      uint64_t =0, uint64_t =0) const;
00060     virtual int64_t getColumnAsUBytes(const char*, unsigned char*,
00061                                       uint64_t =0, uint64_t =0) const;
00062     virtual int64_t getColumnAsShorts(const char*, int16_t*,
00063                                       uint64_t =0, uint64_t =0) const;
00064     virtual int64_t getColumnAsUShorts(const char*, uint16_t*,
00065                                        uint64_t =0, uint64_t =0) const;
00066     virtual int64_t getColumnAsInts(const char*, int32_t*,
00067                                     uint64_t =0, uint64_t =0) const;
00068     virtual int64_t getColumnAsUInts(const char*, uint32_t*,
00069                                      uint64_t =0, uint64_t =0) const;
00070     virtual int64_t getColumnAsLongs(const char*, int64_t*,
00071                                      uint64_t =0, uint64_t =0) const;
00072     virtual int64_t getColumnAsULongs(const char*, uint64_t*,
00073                                       uint64_t =0, uint64_t =0) const;
00074     virtual int64_t getColumnAsFloats(const char*, float*,
00075                                       uint64_t =0, uint64_t =0) const;
00076     virtual int64_t getColumnAsDoubles(const char*, double*,
00077                                        uint64_t =0, uint64_t =0) const;
00078     virtual int64_t getColumnAsDoubles(const char*, std::vector<double>&,
00079                                        uint64_t =0, uint64_t =0) const;
00080     virtual int64_t getColumnAsStrings(const char*, std::vector<std::string>&,
00081                            uint64_t =0, uint64_t =0) const;
00082     virtual double getColumnMin(const char*) const;
00083     virtual double getColumnMax(const char*) const;
00084 
00085     virtual long getHistogram(const char*, const char*,
00086                               double, double, double,
00087                               std::vector<uint32_t>&) const;
00088     virtual long getHistogram2D(const char*, const char*,
00089                                 double, double, double,
00090                                 const char*,
00091                                 double, double, double,
00092                                 std::vector<uint32_t>&) const;
00093     virtual long getHistogram3D(const char*, const char*,
00094                                 double, double, double,
00095                                 const char*,
00096                                 double, double, double,
00097                                 const char*,
00098                                 double, double, double,
00099                                 std::vector<uint32_t>&) const;
00100 
00101     virtual void estimate(const char* cond,
00102                           uint64_t& nmin, uint64_t& nmax) const;
00103     virtual void estimate(const ibis::qExpr* cond,
00104                           uint64_t& nmin, uint64_t& nmax) const;
00105     using table::select;
00106     virtual table* select(const char* sel, const char* cond) const;
00107     virtual table* groupby(const ibis::table::stringList&) const;
00108     virtual table* groupby(const char* str) const;
00109     using table::orderby;
00110     virtual void   orderby(const ibis::table::stringList&);
00111     virtual void   orderby(const ibis::table::stringList&,
00112                            const std::vector<bool>&);
00113     virtual void reverseRows();
00114 
00115     virtual int buildIndex(const char*, const char*) {return -1;}
00116     virtual int buildIndexes(const char*) {return -1;}
00117     virtual int buildIndexes(const char*, int) {return -1;}
00118     virtual int getPartitions(constPartList&) const;
00119     virtual void indexSpec(const char*, const char*) {return;}
00120     virtual const char* indexSpec(const char*) const {return 0;}
00121 
00122     int restoreCategoriesAsStrings(const ibis::part&);
00123     ibis::table* evaluateTerms(const ibis::selectClause&,
00124                                const char*) const;
00125 
00126     int merge(const ibis::bord&, const ibis::selectClause&);
00127     ibis::table* xgroupby(const ibis::selectClause&) const;
00128     ibis::table* groupby(const ibis::selectClause&) const;
00129     static ibis::bord*
00130         groupbya(const ibis::bord&, const ibis::selectClause&);
00131     static ibis::bord*
00132         groupbyc(const ibis::bord&, const ibis::selectClause&);
00133 
00134     virtual long reorder();
00135     virtual long reorder(const ibis::table::stringList&);
00136     virtual long reorder(const ibis::table::stringList&,
00137                          const std::vector<bool>&);
00138 
00139     int append(const ibis::selectClause&, const ibis::part&,
00140                const ibis::bitvector&);
00141     int append(const ibis::selectClause&, const ibis::part&,
00142                const ibis::qContinuousRange&);
00143     int renameColumns(const ibis::selectClause&);
00144     int limit(uint32_t);
00145 
00146     template <typename T>
00147         long sortValues(array_t<T>& vals,
00148                         array_t<uint32_t>& starts,
00149                         array_t<uint32_t>& indout,
00150                         const array_t<uint32_t>& indin,
00151                         bool ascending) const;
00152     template <typename T>
00153         long reorderValues(array_t<T>& vals,
00154                            const array_t<uint32_t>& ind) const;
00155     long sortStrings(std::vector<std::string>& vals,
00156                      array_t<uint32_t>& starts,
00157                      array_t<uint32_t>& idxout,
00158                      const array_t<uint32_t>& idxin,
00159                      bool ascending) const;
00160     long reorderStrings(std::vector<std::string>& vals,
00161                         const array_t<uint32_t>& ind) const;
00162 
00163 
00164     void copyColumn(const char*, ibis::TYPE_T&, void*&,
00165                     const ibis::dictionary*&) const;
00166     static void copyValue(ibis::TYPE_T type,
00167                           void* outbuf, size_t outpos,
00168                           const void* inbuf, size_t inpos);
00169 
00170     // Cursor class for row-wise data accesses.
00171     class cursor;
00173     virtual ibis::table::cursor* createCursor() const;
00174 
00175     // forward declarations
00176     class column;
00177 
00178 protected:
00180     bord() : ibis::part("in-core") {}
00181     void clear();
00182     int64_t computeHits(const char* cond) const;
00183 
00184     static int merger(std::vector<ibis::bord::column*>&,
00185                       std::vector<ibis::bord::column*>&,
00186                       const std::vector<ibis::bord::column*>&,
00187                       const std::vector<ibis::bord::column*>&,
00188                       const std::vector<ibis::selectClause::AGREGADO>&);
00189 
00190     static int merge0(std::vector<ibis::bord::column*>&,
00191                       const std::vector<ibis::bord::column*>&,
00192                       const std::vector<ibis::selectClause::AGREGADO>&);
00193     template <typename T> static int
00194         merge0T(ibis::array_t<T>&, const ibis::array_t<T>&,
00195                 ibis::selectClause::AGREGADO);
00196 
00197     static int merge10(ibis::bord::column&,
00198                        std::vector<ibis::bord::column*>&,
00199                        const ibis::bord::column&,
00200                        const std::vector<ibis::bord::column*>&,
00201                        const std::vector<ibis::selectClause::AGREGADO>&);
00202     template <typename Tk> static int
00203         merge10T(ibis::array_t<Tk> &kout,
00204                  std::vector<ibis::bord::column*>& vout,
00205                  const ibis::array_t<Tk> &kin1,
00206                  const std::vector<ibis::bord::column*> &vin1,
00207                  const ibis::array_t<Tk> &kin2,
00208                  const std::vector<ibis::bord::column*> &vin2,
00209                  const std::vector<ibis::selectClause::AGREGADO>& agg);
00210     static int
00211         merge10S(std::vector<std::string> &kout,
00212                  std::vector<ibis::bord::column*>& vout,
00213                  const std::vector<std::string> &kin1,
00214                  const std::vector<ibis::bord::column*> &vin1,
00215                  const std::vector<std::string> &kin2,
00216                  const std::vector<ibis::bord::column*> &vin2,
00217                  const std::vector<ibis::selectClause::AGREGADO>& agg);
00218 
00219     static int merge11(ibis::bord::column&,
00220                        ibis::bord::column&,
00221                        const ibis::bord::column&,
00222                        const ibis::bord::column&,
00223                        ibis::selectClause::AGREGADO);
00224     template <typename Tk, typename Tv> static int
00225         merge11T(ibis::array_t<Tk> &kout,
00226                  ibis::array_t<Tv> &vout,
00227                  const ibis::array_t<Tk> &kin1,
00228                  const ibis::array_t<Tv> &vin1,
00229                  const ibis::array_t<Tk> &kin2,
00230                  const ibis::array_t<Tv> &vin2,
00231                  ibis::selectClause::AGREGADO agg);
00232     template <typename Tv> static int
00233         merge11S(std::vector<std::string> &kout,
00234                  ibis::array_t<Tv> &vout,
00235                  const std::vector<std::string> &kin1,
00236                  const ibis::array_t<Tv> &vin1,
00237                  const std::vector<std::string> &kin2,
00238                  const ibis::array_t<Tv> &vin2,
00239                  ibis::selectClause::AGREGADO agg);
00240 
00241     static int merge12(ibis::bord::column&,
00242                        ibis::bord::column&,
00243                        ibis::bord::column&,
00244                        const ibis::bord::column&,
00245                        const ibis::bord::column&,
00246                        const ibis::bord::column&,
00247                        ibis::selectClause::AGREGADO,
00248                        ibis::selectClause::AGREGADO);
00249     template <typename Tk> static int
00250         merge12T1(ibis::array_t<Tk> &kout,
00251                   const ibis::array_t<Tk> &kin1,
00252                   const ibis::array_t<Tk> &kin2,
00253                   ibis::bord::column&,
00254                   ibis::bord::column&,
00255                   const ibis::bord::column&,
00256                   const ibis::bord::column&,
00257                   ibis::selectClause::AGREGADO,
00258                   ibis::selectClause::AGREGADO);
00259     template <typename Tk, typename Tu, typename Tv> static int
00260         merge12T(ibis::array_t<Tk> &kout,
00261                  ibis::array_t<Tu> &uout,
00262                  ibis::array_t<Tv> &vout,
00263                  const ibis::array_t<Tk> &kin1,
00264                  const ibis::array_t<Tu> &uin1,
00265                  const ibis::array_t<Tv> &vin1,
00266                  const ibis::array_t<Tk> &kin2,
00267                  const ibis::array_t<Tu> &uin2,
00268                  const ibis::array_t<Tv> &vin2,
00269                  ibis::selectClause::AGREGADO au,
00270                  ibis::selectClause::AGREGADO av);
00271     static int
00272         merge12S1(std::vector<std::string> &kout,
00273                   const std::vector<std::string> &kin1,
00274                   const std::vector<std::string> &kin2,
00275                   ibis::bord::column&,
00276                   ibis::bord::column&,
00277                   const ibis::bord::column&,
00278                   const ibis::bord::column&,
00279                   ibis::selectClause::AGREGADO,
00280                   ibis::selectClause::AGREGADO);
00281     template <typename Tu, typename Tv> static int
00282         merge12S(std::vector<std::string> &kout,
00283                  ibis::array_t<Tu> &uout,
00284                  ibis::array_t<Tv> &vout,
00285                  const std::vector<std::string> &kin1,
00286                  const ibis::array_t<Tu> &uin1,
00287                  const ibis::array_t<Tv> &vin1,
00288                  const std::vector<std::string> &kin2,
00289                  const ibis::array_t<Tu> &uin2,
00290                  const ibis::array_t<Tv> &vin2,
00291                  ibis::selectClause::AGREGADO au,
00292                  ibis::selectClause::AGREGADO av);
00293 
00294     static int merge20(ibis::bord::column &k11,
00295                        ibis::bord::column &k21,
00296                        std::vector<ibis::bord::column*> &v1,
00297                        const ibis::bord::column &k12,
00298                        const ibis::bord::column &k22,
00299                        const std::vector<ibis::bord::column*> &v2,
00300                        const std::vector<ibis::selectClause::AGREGADO> &agg);
00301     template <typename Tk1> static int
00302         merge20T1(ibis::array_t<Tk1> &k1out,
00303                   const ibis::array_t<Tk1> &k1in1,
00304                   const ibis::array_t<Tk1> &k1in2,
00305                   ibis::bord::column &k21,
00306                   std::vector<ibis::bord::column*> &vin1,
00307                   const ibis::bord::column &k22,
00308                   const std::vector<ibis::bord::column*> &vin2,
00309                   const std::vector<ibis::selectClause::AGREGADO> &agg);
00310     template <typename Tk1, typename Tk2> static int
00311         merge20T2(ibis::array_t<Tk1> &k1out,
00312                   ibis::array_t<Tk2> &k2out,
00313                   std::vector<ibis::bord::column*> &vout,
00314                   const ibis::array_t<Tk1> &k1in1,
00315                   const ibis::array_t<Tk2> &k2in1,
00316                   const std::vector<ibis::bord::column*> &vin1,
00317                   const ibis::array_t<Tk1> &k1in2,
00318                   const ibis::array_t<Tk2> &k2in2,
00319                   const std::vector<ibis::bord::column*> &vin2,
00320                   const std::vector<ibis::selectClause::AGREGADO> &agg);
00321     static int
00322         merge20S0(std::vector<std::string> &k1out,
00323                   std::vector<std::string> &k2out,
00324                   std::vector<ibis::bord::column*> &vout,
00325                   const std::vector<std::string> &k1in1,
00326                   const std::vector<std::string> &k2in1,
00327                   const std::vector<ibis::bord::column*> &vin1,
00328                   const std::vector<std::string> &k1in2,
00329                   const std::vector<std::string> &k2in2,
00330                   const std::vector<ibis::bord::column*> &vin2,
00331                   const std::vector<ibis::selectClause::AGREGADO> &agg);
00332     static int
00333         merge20S1(std::vector<std::string> &k1out,
00334                   const std::vector<std::string> &k1in1,
00335                   const std::vector<std::string> &k1in2,
00336                   ibis::bord::column &k21,
00337                   std::vector<ibis::bord::column*> &vin1,
00338                   const ibis::bord::column &k22,
00339                   const std::vector<ibis::bord::column*> &vin2,
00340                   const std::vector<ibis::selectClause::AGREGADO> &agg);
00341     template <typename Tk2> static int
00342         merge20S2(std::vector<std::string> &k1out,
00343                   ibis::array_t<Tk2> &k2out,
00344                   std::vector<ibis::bord::column*> &vout,
00345                   const std::vector<std::string> &k1in1,
00346                   const ibis::array_t<Tk2> &k2in1,
00347                   const std::vector<ibis::bord::column*> &vin1,
00348                   const std::vector<std::string> &k1in2,
00349                   const ibis::array_t<Tk2> &k2in2,
00350                   const std::vector<ibis::bord::column*> &vin2,
00351                   const std::vector<ibis::selectClause::AGREGADO> &agg);
00352     template <typename Tk1> static int
00353         merge20S3(ibis::array_t<Tk1> &k1out,
00354                   std::vector<std::string> &k2out,
00355                   std::vector<ibis::bord::column*> &vout,
00356                   const ibis::array_t<Tk1> &k1in1,
00357                   const std::vector<std::string> &k2in1,
00358                   const std::vector<ibis::bord::column*> &vin1,
00359                   const ibis::array_t<Tk1> &k1in2,
00360                   const std::vector<std::string> &k2in2,
00361                   const std::vector<ibis::bord::column*> &vin2,
00362                   const std::vector<ibis::selectClause::AGREGADO> &agg);
00363 
00364     static int merge21(ibis::bord::column &k11,
00365                        ibis::bord::column &k21,
00366                        ibis::bord::column &v1,
00367                        const ibis::bord::column &k12,
00368                        const ibis::bord::column &k22,
00369                        const ibis::bord::column &v2,
00370                        ibis::selectClause::AGREGADO ag);
00371     template <typename Tk1> static int
00372         merge21T1(ibis::array_t<Tk1> &k1out,
00373                   const ibis::array_t<Tk1> &k1in1,
00374                   const ibis::array_t<Tk1> &k1in2,
00375                   ibis::bord::column &k21,
00376                   ibis::bord::column &v1,
00377                   const ibis::bord::column &k22,
00378                   const ibis::bord::column &v2,
00379                   ibis::selectClause::AGREGADO ag);
00380     template <typename Tk1, typename Tk2> static int
00381         merge21T2(ibis::array_t<Tk1> &k1out,
00382                   ibis::array_t<Tk2> &k2out,
00383                   const ibis::array_t<Tk1> &k1in1,
00384                   const ibis::array_t<Tk2> &k2in1,
00385                   const ibis::array_t<Tk1> &k1in2,
00386                   const ibis::array_t<Tk2> &k2in2,
00387                   ibis::bord::column &v1,
00388                   const ibis::bord::column &v2,
00389                   ibis::selectClause::AGREGADO ag);
00390     template <typename Tk1, typename Tk2, typename Tv> static int
00391         merge21T3(ibis::array_t<Tk1> &k1out,
00392                   ibis::array_t<Tk2> &k2out,
00393                   ibis::array_t<Tv>  &vout,
00394                   const ibis::array_t<Tk1> &k1in1,
00395                   const ibis::array_t<Tk2> &k2in1,
00396                   const ibis::array_t<Tv>  &vin1,
00397                   const ibis::array_t<Tk1> &k1in2,
00398                   const ibis::array_t<Tk2> &k2in2,
00399                   const ibis::array_t<Tv>  &vin2,
00400                   ibis::selectClause::AGREGADO av);
00401     static int
00402         merge21S1(std::vector<std::string> &k1out,
00403                   const std::vector<std::string> &k1in1,
00404                   const std::vector<std::string> &k1in2,
00405                   ibis::bord::column &k21,
00406                   ibis::bord::column &v1,
00407                   const ibis::bord::column &k22,
00408                   const ibis::bord::column &v2,
00409                   ibis::selectClause::AGREGADO ag);
00410     template <typename Tk2> static int
00411         merge21S2(std::vector<std::string> &k1out,
00412                   ibis::array_t<Tk2> &k2out,
00413                   const std::vector<std::string> &k1in1,
00414                   const ibis::array_t<Tk2> &k2in1,
00415                   const std::vector<std::string> &k1in2,
00416                   const ibis::array_t<Tk2> &k2in2,
00417                   ibis::bord::column &v1,
00418                   const ibis::bord::column &v2,
00419                   ibis::selectClause::AGREGADO ag);
00420     template <typename Tk2, typename Tv> static int
00421         merge21S3(std::vector<std::string> &k1out,
00422                   ibis::array_t<Tk2> &k2out,
00423                   ibis::array_t<Tv>  &vout,
00424                   const std::vector<std::string> &k1in1,
00425                   const ibis::array_t<Tk2> &k2in1,
00426                   const ibis::array_t<Tv>  &vin1,
00427                   const std::vector<std::string> &k1in2,
00428                   const ibis::array_t<Tk2> &k2in2,
00429                   const ibis::array_t<Tv>  &vin2,
00430                   ibis::selectClause::AGREGADO av);
00431     static int
00432         merge21S4(std::vector<std::string> &k1out,
00433                   std::vector<std::string> &k2out,
00434                   const std::vector<std::string> &k1in1,
00435                   const std::vector<std::string> &k2in1,
00436                   const std::vector<std::string> &k1in2,
00437                   const std::vector<std::string> &k2in2,
00438                   ibis::bord::column &v1,
00439                   const ibis::bord::column &v2,
00440                   ibis::selectClause::AGREGADO ag);
00441     template <typename Tv> static int
00442         merge21S5(std::vector<std::string> &k1out,
00443                   std::vector<std::string> &k2out,
00444                   ibis::array_t<Tv>  &vout,
00445                   const std::vector<std::string> &k1in1,
00446                   const std::vector<std::string> &k2in1,
00447                   const ibis::array_t<Tv>  &vin1,
00448                   const std::vector<std::string> &k1in2,
00449                   const std::vector<std::string> &k2in2,
00450                   const ibis::array_t<Tv>  &vin2,
00451                   ibis::selectClause::AGREGADO av);
00452     template <typename Tk1> static int
00453         merge21S6(ibis::array_t<Tk1> &k1out,
00454                   std::vector<std::string> &k2out,
00455                   const ibis::array_t<Tk1> &k1in1,
00456                   const std::vector<std::string> &k2in1,
00457                   const ibis::array_t<Tk1> &k1in2,
00458                   const std::vector<std::string> &k2in2,
00459                   ibis::bord::column &v1,
00460                   const ibis::bord::column &v2,
00461                   ibis::selectClause::AGREGADO ag);
00462     template <typename Tk1, typename Tv> static int
00463         merge21S7(ibis::array_t<Tk1> &k1out,
00464                   std::vector<std::string> &k2out,
00465                   ibis::array_t<Tv>  &vout,
00466                   const ibis::array_t<Tk1> &k1in1,
00467                   const std::vector<std::string> &k2in1,
00468                   const ibis::array_t<Tv>  &vin1,
00469                   const ibis::array_t<Tk1> &k1in2,
00470                   const std::vector<std::string> &k2in2,
00471                   const ibis::array_t<Tv>  &vin2,
00472                   ibis::selectClause::AGREGADO av);
00473 
00474 private:
00475     // disallow copying.
00476     bord(const bord&);
00477     bord& operator=(const bord&);
00478 
00479     friend class cursor;
00480 }; // ibis::bord
00481 
00491 class ibis::bord::column : public ibis::column {
00492 public:
00493     column(const ibis::bord* tbl, ibis::TYPE_T t, const char* name,
00494            void *buf=0, const char* desc="", double low=DBL_MAX,
00495            double high=-DBL_MAX);
00496     column(const ibis::bord*, const ibis::column&, void *buf);
00497     column(const column& rhs);
00498     virtual ~column();
00499 
00500     virtual ibis::fileManager::storage* getRawData() const;
00501 
00502     using ibis::column::evaluateRange;
00503     virtual long evaluateRange(const ibis::qContinuousRange& cmp,
00504                                const ibis::bitvector& mask,
00505                                ibis::bitvector& res) const;
00506     virtual long evaluateRange(const ibis::qDiscreteRange& cmp,
00507                                const ibis::bitvector& mask,
00508                                ibis::bitvector& res) const;
00509     virtual long stringSearch(const char*, ibis::bitvector&) const;
00510     virtual long stringSearch(const std::vector<std::string>&,
00511                               ibis::bitvector&) const;
00512     virtual long stringSearch(const char*) const;
00513     virtual long stringSearch(const std::vector<std::string>&) const;
00514     virtual long keywordSearch(const char*, ibis::bitvector&) const;
00515     virtual long keywordSearch(const char*) const;
00516     virtual long patternSearch(const char*) const;
00517     virtual long patternSearch(const char*, ibis::bitvector &) const;
00518 
00519     virtual array_t<signed char>*   selectBytes(const ibis::bitvector&) const;
00520     virtual array_t<unsigned char>* selectUBytes(const ibis::bitvector&) const;
00521     virtual array_t<int16_t>*       selectShorts(const ibis::bitvector&) const;
00522     virtual array_t<uint16_t>*      selectUShorts(const ibis::bitvector&) const;
00523     virtual array_t<int32_t>*       selectInts(const ibis::bitvector&) const;
00524     virtual array_t<uint32_t>*      selectUInts(const ibis::bitvector&) const;
00525     virtual array_t<int64_t>*       selectLongs(const ibis::bitvector&) const;
00526     virtual array_t<uint64_t>*      selectULongs(const ibis::bitvector&) const;
00527     virtual array_t<float>*         selectFloats(const ibis::bitvector&) const;
00528     virtual array_t<double>*        selectDoubles(const ibis::bitvector&) const;
00529     virtual std::vector<std::string>*
00530         selectStrings(const bitvector& mask) const;
00531 
00532     virtual long append(const char* dt, const char* df, const uint32_t nold,
00533                         const uint32_t nnew, uint32_t nbuf, char* buf);
00534     virtual long append(const void* vals, const ibis::bitvector& msk);
00535     virtual long append(const ibis::column& scol, const ibis::bitvector& msk);
00536     virtual long append(const ibis::column& scol,
00537                         const ibis::qContinuousRange& cnd);
00538 
00539     virtual void computeMinMax() {
00540         computeMinMax(thePart->currentDataDir(), lower, upper);}
00541     virtual void computeMinMax(const char *dir) {
00542         computeMinMax(dir, lower, upper);}
00543     virtual void computeMinMax(const char *, double &min, double &max) const;
00544     virtual void getString(uint32_t i, std::string &val) const;
00545     virtual int  getValuesArray(void* vals) const;
00546 
00547     void reverseRows();
00548     int  limit(uint32_t nr);
00549 
00550     void*& getArray() {return buffer;}
00551     void*  getArray() const {return buffer;}
00552     int dump(std::ostream& out, uint32_t i) const;
00553 
00554     bool equal_to(const column&) const;
00555     inline bool equal_to(const column&, uint32_t, uint32_t) const;
00556     inline bool less_than(const column&, uint32_t, uint32_t) const;
00557     inline void append(const void*, uint32_t);
00558     inline void append(const void*, uint32_t, const void*, uint32_t,
00559                        ibis::selectClause::AGREGADO);
00560     void addCounts(uint32_t);
00561 
00562     int restoreCategoriesAsStrings(const ibis::category&);
00565     template <typename T> static int 
00566         addIncoreData(array_t<T>*& to, uint32_t nold, const array_t<T>& from,
00567                       const T special);
00568     static int addStrings(std::vector<std::string>*&, uint32_t,
00569                           const std::vector<std::string>&);
00570 
00574     const ibis::dictionary* getDictionary() const {return dic;}
00576     void setDictionary(const ibis::dictionary* d) {dic = d;}
00577 
00578 protected:
00581     void *buffer;
00585     const ibis::dictionary *dic;
00586 
00587     column& operator=(const column&); // no assignment
00588 }; // ibis::bord::column
00589 
00590 class FASTBIT_CXX_DLLSPEC ibis::bord::cursor : public ibis::table::cursor {
00591 public:
00592     cursor(const ibis::bord& t);
00593     virtual ~cursor() {};
00594 
00595     virtual uint64_t nRows() const {return tab.nRows();}
00596     virtual uint32_t nColumns() const {return tab.nColumns();}
00597     virtual ibis::table::stringList columnNames() const {
00598         return tab.columnNames();}
00599     virtual ibis::table::typeList columnTypes() const {
00600         return tab.columnTypes();}
00601     virtual int fetch();
00602     virtual int fetch(uint64_t);
00603     virtual int fetch(ibis::table::row&);
00604     virtual int fetch(uint64_t, ibis::table::row&);
00605     virtual uint64_t getCurrentRowNumber() const {return curRow;}
00606     virtual int dump(std::ostream& out, const char* del) const;
00607 
00608     virtual int getColumnAsByte(const char*, char&) const;
00609     virtual int getColumnAsUByte(const char*, unsigned char&) const;
00610     virtual int getColumnAsShort(const char*, int16_t&) const;
00611     virtual int getColumnAsUShort(const char*, uint16_t&) const;
00612     virtual int getColumnAsInt(const char*, int32_t&) const;
00613     virtual int getColumnAsUInt(const char*, uint32_t&) const;
00614     virtual int getColumnAsLong(const char*, int64_t&) const;
00615     virtual int getColumnAsULong(const char*, uint64_t&) const;
00616     virtual int getColumnAsFloat(const char*, float&) const;
00617     virtual int getColumnAsDouble(const char*, double&) const;
00618     virtual int getColumnAsString(const char*, std::string&) const;
00619 
00620     virtual int getColumnAsByte(uint32_t, char&) const;
00621     virtual int getColumnAsUByte(uint32_t, unsigned char&) const;
00622     virtual int getColumnAsShort(uint32_t, int16_t&) const;
00623     virtual int getColumnAsUShort(uint32_t, uint16_t&) const;
00624     virtual int getColumnAsInt(uint32_t, int32_t&) const;
00625     virtual int getColumnAsUInt(uint32_t, uint32_t&) const;
00626     virtual int getColumnAsLong(uint32_t, int64_t&) const;
00627     virtual int getColumnAsULong(uint32_t, uint64_t&) const;
00628     virtual int getColumnAsFloat(uint32_t, float&) const;
00629     virtual int getColumnAsDouble(uint32_t, double&) const;
00630     virtual int getColumnAsString(uint32_t, std::string&) const;
00631 
00632 protected:
00633     struct bufferElement {
00634         const char* cname;
00635         ibis::TYPE_T ctype;
00636         void* cval;
00637         const ibis::dictionary* dic;
00638 
00639         bufferElement() : cname(0), ctype(ibis::UNKNOWN_TYPE), cval(0) , dic(0) {}
00640     }; // bufferElement
00641     typedef std::map<const char*, uint32_t, ibis::lessi> bufferMap;
00642     std::vector<bufferElement> buffer;
00643     bufferMap bufmap;
00644     const ibis::bord& tab;
00645     int64_t curRow; // the current row number
00646 
00647     void fillRow(ibis::table::row& res) const;
00648     int dumpIJ(std::ostream&, uint32_t, uint32_t) const;
00649 
00650 private:
00651     cursor();
00652     cursor(const cursor&);
00653     cursor& operator=(const cursor&);
00654 }; // ibis::bord::cursor
00655 
00659 inline void
00660 ibis::bord::copyValue(ibis::TYPE_T type, void* outbuf, size_t outpos,
00661                       const void* inbuf, size_t inpos) {
00662     switch (type) {
00663     default:
00664         break;
00665     case ibis::BYTE: {
00666         (*static_cast<array_t<signed char>*>(outbuf))[outpos]
00667             = (*static_cast<const array_t<signed char>*>(inbuf))[inpos];
00668         break;}
00669     case ibis::UBYTE: {
00670         (*static_cast<array_t<unsigned char>*>(outbuf))[outpos]
00671             = (*static_cast<const array_t<unsigned char>*>(inbuf))[inpos];
00672         break;}
00673     case ibis::SHORT: {
00674         (*static_cast<array_t<int16_t>*>(outbuf))[outpos]
00675             = (*static_cast<const array_t<int16_t>*>(inbuf))[inpos];
00676         break;}
00677     case ibis::USHORT: {
00678         (*static_cast<array_t<uint16_t>*>(outbuf))[outpos]
00679             = (*static_cast<const array_t<uint16_t>*>(inbuf))[inpos];
00680         break;}
00681     case ibis::INT: {
00682         (*static_cast<array_t<int32_t>*>(outbuf))[outpos]
00683             = (*static_cast<const array_t<int32_t>*>(inbuf))[inpos];
00684         break;}
00685     case ibis::UINT: {
00686         (*static_cast<array_t<uint32_t>*>(outbuf))[outpos]
00687             = (*static_cast<const array_t<uint32_t>*>(inbuf))[inpos];
00688         break;}
00689     case ibis::LONG: {
00690         (*static_cast<array_t<int64_t>*>(outbuf))[outpos]
00691             = (*static_cast<const array_t<int64_t>*>(inbuf))[inpos];
00692         break;}
00693     case ibis::ULONG: {
00694         (*static_cast<array_t<uint64_t>*>(outbuf))[outpos]
00695             = (*static_cast<const array_t<uint64_t>*>(inbuf))[inpos];
00696         break;}
00697     case ibis::FLOAT: {
00698         (*static_cast<array_t<float>*>(outbuf))[outpos]
00699             = (*static_cast<const array_t<float>*>(inbuf))[inpos];
00700         break;}
00701     case ibis::DOUBLE: {
00702         (*static_cast<array_t<double>*>(outbuf))[outpos]
00703             = (*static_cast<const array_t<double>*>(inbuf))[inpos];
00704         break;}
00705     case ibis::BLOB:
00706     case ibis::TEXT:
00707     case ibis::CATEGORY: {
00708         (*static_cast<std::vector<std::string>*>(outbuf))[outpos]
00709         = (*static_cast<const std::vector<std::string>*>(inbuf))[inpos];
00710         break;}
00711     }
00712 } //ibis::bord::copyValue
00713 
00715 inline bool
00716 ibis::bord::column::equal_to(const ibis::bord::column &other,
00717                              uint32_t i, uint32_t j) const {
00718     if (m_type != other.m_type) return false;
00719     if (buffer == 0 || other.buffer == 0) return false;
00720     if (buffer == other.buffer && i == j) return true;
00721 
00722     switch (m_type) {
00723     default:
00724         return false;
00725     case ibis::BYTE: {
00726         const ibis::array_t<signed char> &v0 =
00727             *static_cast<const ibis::array_t<signed char>*>(buffer);
00728         const ibis::array_t<signed char> &v1 =
00729             *static_cast<const ibis::array_t<signed char>*>(other.buffer);
00730         return (v0[i] == v1[j]);}
00731     case ibis::UBYTE: {
00732         const ibis::array_t<unsigned char> &v0 =
00733             *static_cast<const ibis::array_t<unsigned char>*>(buffer);
00734         const ibis::array_t<unsigned char> &v1 =
00735             *static_cast<const ibis::array_t<unsigned char>*>(other.buffer);
00736         return (v0[i] == v1[j]);}
00737     case ibis::SHORT: {
00738         const ibis::array_t<int16_t> &v0 =
00739             *static_cast<const ibis::array_t<int16_t>*>(buffer);
00740         const ibis::array_t<int16_t> &v1 =
00741             *static_cast<const ibis::array_t<int16_t>*>(other.buffer);
00742         return (v0[i] == v1[j]);}
00743     case ibis::USHORT: {
00744         const ibis::array_t<uint16_t> &v0 =
00745             *static_cast<const ibis::array_t<uint16_t>*>(buffer);
00746         const ibis::array_t<uint16_t> &v1 =
00747             *static_cast<const ibis::array_t<uint16_t>*>(other.buffer);
00748         return (v0[i] == v1[j]);}
00749     case ibis::INT: {
00750         const ibis::array_t<int32_t> &v0 =
00751             *static_cast<const ibis::array_t<int32_t>*>(buffer);
00752         const ibis::array_t<int32_t> &v1 =
00753             *static_cast<const ibis::array_t<int32_t>*>(other.buffer);
00754         return (v0[i] == v1[j]);}
00755     case ibis::UINT: {
00756         const ibis::array_t<uint32_t> &v0 =
00757             *static_cast<const ibis::array_t<uint32_t>*>(buffer);
00758         const ibis::array_t<uint32_t> &v1 =
00759             *static_cast<const ibis::array_t<uint32_t>*>(other.buffer);
00760         return (v0[i] == v1[j]);}
00761     case ibis::LONG: {
00762         const ibis::array_t<int64_t> &v0 =
00763             *static_cast<const ibis::array_t<int64_t>*>(buffer);
00764         const ibis::array_t<int64_t> &v1 =
00765             *static_cast<const ibis::array_t<int64_t>*>(other.buffer);
00766         return (v0[i] == v1[j]);}
00767     case ibis::ULONG: {
00768         const ibis::array_t<uint64_t> &v0 =
00769             *static_cast<const ibis::array_t<uint64_t>*>(buffer);
00770         const ibis::array_t<uint64_t> &v1 =
00771             *static_cast<const ibis::array_t<uint64_t>*>(other.buffer);
00772         return (v0[i] == v1[j]);}
00773     case ibis::FLOAT: {
00774         const ibis::array_t<float> &v0 =
00775             *static_cast<const ibis::array_t<float>*>(buffer);
00776         const ibis::array_t<float> &v1 =
00777             *static_cast<const ibis::array_t<float>*>(other.buffer);
00778         return (v0[i] == v1[j]);}
00779     case ibis::DOUBLE: {
00780         const ibis::array_t<double> &v0 =
00781             *static_cast<const ibis::array_t<double>*>(buffer);
00782         const ibis::array_t<double> &v1 =
00783             *static_cast<const ibis::array_t<double>*>(other.buffer);
00784         return (v0[i] == v1[j]);}
00785     }
00786 } // ibis::bord::column::equal_to
00787 
00789 inline bool
00790 ibis::bord::column::less_than(const ibis::bord::column &other,
00791                               uint32_t i, uint32_t j) const {
00792     if (m_type != other.m_type) return false;
00793     if (buffer == 0 || other.buffer == 0) return false;
00794     if (buffer == other.buffer && i == j) return true;
00795 
00796     switch (m_type) {
00797     default:
00798         return false;
00799     case ibis::BYTE: {
00800         const ibis::array_t<signed char> &v0 =
00801             *static_cast<const ibis::array_t<signed char>*>(buffer);
00802         const ibis::array_t<signed char> &v1 =
00803             *static_cast<const ibis::array_t<signed char>*>(other.buffer);
00804         return (v0[i] < v1[j]);}
00805     case ibis::UBYTE: {
00806         const ibis::array_t<unsigned char> &v0 =
00807             *static_cast<const ibis::array_t<unsigned char>*>(buffer);
00808         const ibis::array_t<unsigned char> &v1 =
00809             *static_cast<const ibis::array_t<unsigned char>*>(other.buffer);
00810         return (v0[i] < v1[j]);}
00811     case ibis::SHORT: {
00812         const ibis::array_t<int16_t> &v0 =
00813             *static_cast<const ibis::array_t<int16_t>*>(buffer);
00814         const ibis::array_t<int16_t> &v1 =
00815             *static_cast<const ibis::array_t<int16_t>*>(other.buffer);
00816         return (v0[i] < v1[j]);}
00817     case ibis::USHORT: {
00818         const ibis::array_t<uint16_t> &v0 =
00819             *static_cast<const ibis::array_t<uint16_t>*>(buffer);
00820         const ibis::array_t<uint16_t> &v1 =
00821             *static_cast<const ibis::array_t<uint16_t>*>(other.buffer);
00822         return (v0[i] < v1[j]);}
00823     case ibis::INT: {
00824         const ibis::array_t<int32_t> &v0 =
00825             *static_cast<const ibis::array_t<int32_t>*>(buffer);
00826         const ibis::array_t<int32_t> &v1 =
00827             *static_cast<const ibis::array_t<int32_t>*>(other.buffer);
00828         return (v0[i] < v1[j]);}
00829     case ibis::UINT: {
00830         const ibis::array_t<uint32_t> &v0 =
00831             *static_cast<const ibis::array_t<uint32_t>*>(buffer);
00832         const ibis::array_t<uint32_t> &v1 =
00833             *static_cast<const ibis::array_t<uint32_t>*>(other.buffer);
00834         return (v0[i] < v1[j]);}
00835     case ibis::LONG: {
00836         const ibis::array_t<int64_t> &v0 =
00837             *static_cast<const ibis::array_t<int64_t>*>(buffer);
00838         const ibis::array_t<int64_t> &v1 =
00839             *static_cast<const ibis::array_t<int64_t>*>(other.buffer);
00840         return (v0[i] < v1[j]);}
00841     case ibis::ULONG: {
00842         const ibis::array_t<uint64_t> &v0 =
00843             *static_cast<const ibis::array_t<uint64_t>*>(buffer);
00844         const ibis::array_t<uint64_t> &v1 =
00845             *static_cast<const ibis::array_t<uint64_t>*>(other.buffer);
00846         return (v0[i] < v1[j]);}
00847     case ibis::FLOAT: {
00848         const ibis::array_t<float> &v0 =
00849             *static_cast<const ibis::array_t<float>*>(buffer);
00850         const ibis::array_t<float> &v1 =
00851             *static_cast<const ibis::array_t<float>*>(other.buffer);
00852         return (v0[i] < v1[j]);}
00853     case ibis::DOUBLE: {
00854         const ibis::array_t<double> &v0 =
00855             *static_cast<const ibis::array_t<double>*>(buffer);
00856         const ibis::array_t<double> &v1 =
00857             *static_cast<const ibis::array_t<double>*>(other.buffer);
00858         return (v0[i] < v1[j]);}
00859     }
00860 } // ibis::bord::column::less_than
00861 
00866 inline void
00867 ibis::bord::column::append(const void* c1, uint32_t i1) {
00868     switch (m_type) {
00869     default:
00870         break;
00871     case ibis::BYTE: {
00872         ibis::array_t<signed char>& v0 =
00873             *(static_cast<array_t<signed char>*>(buffer));
00874         const ibis::array_t<signed char>& v1 =
00875             *(static_cast<const array_t<signed char>*>(c1));
00876         v0.push_back(v1[i1]);
00877         break;}
00878     case ibis::UBYTE: {
00879         ibis::array_t<unsigned char>& v0 =
00880             *(static_cast<array_t<unsigned char>*>(buffer));
00881         const ibis::array_t<unsigned char>& v1 =
00882             *(static_cast<const array_t<unsigned char>*>(c1));
00883         v0.push_back(v1[i1]);
00884         break;}
00885     case ibis::SHORT: {
00886         ibis::array_t<int16_t>& v0 =
00887             *(static_cast<array_t<int16_t>*>(buffer));
00888         const ibis::array_t<int16_t>& v1 =
00889             *(static_cast<const array_t<int16_t>*>(c1));
00890         v0.push_back(v1[i1]);
00891         break;}
00892     case ibis::USHORT: {
00893         ibis::array_t<uint16_t>& v0 =
00894             *(static_cast<array_t<uint16_t>*>(buffer));
00895         const ibis::array_t<uint16_t>& v1 =
00896             *(static_cast<const array_t<uint16_t>*>(c1));
00897         v0.push_back(v1[i1]);
00898         break;}
00899     case ibis::INT: {
00900         ibis::array_t<int32_t>& v0 =
00901             *(static_cast<array_t<int32_t>*>(buffer));
00902         const ibis::array_t<int32_t>& v1 =
00903             *(static_cast<const array_t<int32_t>*>(c1));
00904         v0.push_back(v1[i1]);
00905         break;}
00906     case ibis::UINT: {
00907         ibis::array_t<uint32_t>& v0 =
00908             *(static_cast<array_t<uint32_t>*>(buffer));
00909         const ibis::array_t<uint32_t>& v1 =
00910             *(static_cast<const array_t<uint32_t>*>(c1));
00911         v0.push_back(v1[i1]);
00912         break;}
00913     case ibis::LONG: {
00914         ibis::array_t<int64_t>& v0 =
00915             *(static_cast<array_t<int64_t>*>(buffer));
00916         const ibis::array_t<int64_t>& v1 =
00917             *(static_cast<const array_t<int64_t>*>(c1));
00918         v0.push_back(v1[i1]);
00919         break;}
00920     case ibis::ULONG: {
00921         ibis::array_t<uint64_t>& v0 =
00922             *(static_cast<array_t<uint64_t>*>(buffer));
00923         const ibis::array_t<uint64_t>& v1 =
00924             *(static_cast<const array_t<uint64_t>*>(c1));
00925         v0.push_back(v1[i1]);
00926         break;}
00927     case ibis::FLOAT: {
00928         ibis::array_t<float>& v0 =
00929             *(static_cast<array_t<float>*>(buffer));
00930         const ibis::array_t<float>& v1 =
00931             *(static_cast<const array_t<float>*>(c1));
00932         v0.push_back(v1[i1]);
00933         break;}
00934     case ibis::DOUBLE: {
00935         ibis::array_t<double>& v0 =
00936             *(static_cast<array_t<double>*>(buffer));
00937         const ibis::array_t<double>& v1 =
00938             *(static_cast<const array_t<double>*>(c1));
00939         v0.push_back(v1[i1]);
00940         break;}
00941     }
00942 } // ibis::bord::column::append
00943 
00949 inline void
00950 ibis::bord::column::append(const void* c1, uint32_t i1,
00951                            const void* c2, uint32_t i2,
00952                            ibis::selectClause::AGREGADO agg) {
00953     switch (m_type) {
00954     default:
00955         return;
00956     case ibis::BYTE: {
00957         ibis::array_t<signed char>& v0 =
00958             *(static_cast<array_t<signed char>*>(buffer));
00959         const ibis::array_t<signed char>& v1 =
00960             *(static_cast<const array_t<signed char>*>(c1));
00961         const ibis::array_t<signed char>& v2 =
00962             *(static_cast<const array_t<signed char>*>(c2));
00963         signed char tmp = 0;
00964         switch (agg) {
00965         default:
00966             break;
00967         case ibis::selectClause::CNT:
00968         case ibis::selectClause::SUM:
00969             tmp = v1[i1] + v2[i2];
00970             break;
00971         case ibis::selectClause::MIN:
00972             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
00973             break;
00974         case ibis::selectClause::MAX:
00975             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
00976             break;
00977         }
00978         v0.push_back(tmp);
00979         break;}
00980     case ibis::UBYTE: {
00981         ibis::array_t<unsigned char>& v0 =
00982             *(static_cast<array_t<unsigned char>*>(buffer));
00983         const ibis::array_t<unsigned char>& v1 =
00984             *(static_cast<const array_t<unsigned char>*>(c1));
00985         const ibis::array_t<unsigned char>& v2 =
00986             *(static_cast<const array_t<unsigned char>*>(c2));
00987         unsigned char tmp = 0;
00988         switch (agg) {
00989         default:
00990             break;
00991         case ibis::selectClause::CNT:
00992         case ibis::selectClause::SUM:
00993             tmp = v1[i1] + v2[i2];
00994             break;
00995         case ibis::selectClause::MIN:
00996             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
00997             break;
00998         case ibis::selectClause::MAX:
00999             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
01000             break;
01001         }
01002         v0.push_back(tmp);
01003         break;}
01004     case ibis::SHORT: {
01005         ibis::array_t<int16_t>& v0 =
01006             *(static_cast<array_t<int16_t>*>(buffer));
01007         const ibis::array_t<int16_t>& v1 =
01008             *(static_cast<const array_t<int16_t>*>(c1));
01009         const ibis::array_t<int16_t>& v2 =
01010             *(static_cast<const array_t<int16_t>*>(c2));
01011         int16_t tmp = 0;
01012         switch (agg) {
01013         default:
01014             break;
01015         case ibis::selectClause::CNT:
01016         case ibis::selectClause::SUM:
01017             tmp = v1[i1] + v2[i2];
01018             break;
01019         case ibis::selectClause::MIN:
01020             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
01021             break;
01022         case ibis::selectClause::MAX:
01023             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
01024             break;
01025         }
01026         v0.push_back(tmp);
01027         break;}
01028     case ibis::USHORT: {
01029         ibis::array_t<uint16_t>& v0 =
01030             *(static_cast<array_t<uint16_t>*>(buffer));
01031         const ibis::array_t<uint16_t>& v1 =
01032             *(static_cast<const array_t<uint16_t>*>(c1));
01033         const ibis::array_t<uint16_t>& v2 =
01034             *(static_cast<const array_t<uint16_t>*>(c2));
01035         uint16_t tmp = 0;
01036         switch (agg) {
01037         default:
01038             break;
01039         case ibis::selectClause::CNT:
01040         case ibis::selectClause::SUM:
01041             tmp = v1[i1] + v2[i2];
01042             break;
01043         case ibis::selectClause::MIN:
01044             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
01045             break;
01046         case ibis::selectClause::MAX:
01047             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
01048             break;
01049         }
01050         v0.push_back(tmp);
01051         break;}
01052     case ibis::INT: {
01053         ibis::array_t<int32_t>& v0 =
01054             *(static_cast<array_t<int32_t>*>(buffer));
01055         const ibis::array_t<int32_t>& v1 =
01056             *(static_cast<const array_t<int32_t>*>(c1));
01057         const ibis::array_t<int32_t>& v2 =
01058             *(static_cast<const array_t<int32_t>*>(c2));
01059         int32_t tmp = 0;
01060         switch (agg) {
01061         default:
01062             break;
01063         case ibis::selectClause::CNT:
01064         case ibis::selectClause::SUM:
01065             tmp = v1[i1] + v2[i2];
01066             break;
01067         case ibis::selectClause::MIN:
01068             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
01069             break;
01070         case ibis::selectClause::MAX:
01071             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
01072             break;
01073         }
01074         v0.push_back(tmp);
01075         break;}
01076     case ibis::UINT: {
01077         ibis::array_t<uint32_t>& v0 =
01078             *(static_cast<array_t<uint32_t>*>(buffer));
01079         const ibis::array_t<uint32_t>& v1 =
01080             *(static_cast<const array_t<uint32_t>*>(c1));
01081         const ibis::array_t<uint32_t>& v2 =
01082             *(static_cast<const array_t<uint32_t>*>(c2));
01083         uint32_t tmp = 0;
01084         switch (agg) {
01085         default:
01086             break;
01087         case ibis::selectClause::CNT:
01088         case ibis::selectClause::SUM:
01089             tmp = v1[i1] + v2[i2];
01090             break;
01091         case ibis::selectClause::MIN:
01092             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
01093             break;
01094         case ibis::selectClause::MAX:
01095             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
01096             break;
01097         }
01098         v0.push_back(tmp);
01099         break;}
01100     case ibis::LONG: {
01101         ibis::array_t<int64_t>& v0 =
01102             *(static_cast<array_t<int64_t>*>(buffer));
01103         const ibis::array_t<int64_t>& v1 =
01104             *(static_cast<const array_t<int64_t>*>(c1));
01105         const ibis::array_t<int64_t>& v2 =
01106             *(static_cast<const array_t<int64_t>*>(c2));
01107         int64_t tmp = 0;
01108         switch (agg) {
01109         default:
01110             break;
01111         case ibis::selectClause::CNT:
01112         case ibis::selectClause::SUM:
01113             tmp = v1[i1] + v2[i2];
01114             break;
01115         case ibis::selectClause::MIN:
01116             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
01117             break;
01118         case ibis::selectClause::MAX:
01119             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
01120             break;
01121         }
01122         v0.push_back(tmp);
01123         break;}
01124     case ibis::ULONG: {
01125         ibis::array_t<uint64_t>& v0 =
01126             *(static_cast<array_t<uint64_t>*>(buffer));
01127         const ibis::array_t<uint64_t>& v1 =
01128             *(static_cast<const array_t<uint64_t>*>(c1));
01129         const ibis::array_t<uint64_t>& v2 =
01130             *(static_cast<const array_t<uint64_t>*>(c2));
01131         uint64_t tmp = 0;
01132         switch (agg) {
01133         default:
01134             break;
01135         case ibis::selectClause::CNT:
01136         case ibis::selectClause::SUM:
01137             tmp = v1[i1] + v2[i2];
01138             break;
01139         case ibis::selectClause::MIN:
01140             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
01141             break;
01142         case ibis::selectClause::MAX:
01143             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
01144             break;
01145         }
01146         v0.push_back(tmp);
01147         break;}
01148     case ibis::FLOAT: {
01149         ibis::array_t<float>& v0 =
01150             *(static_cast<array_t<float>*>(buffer));
01151         const ibis::array_t<float>& v1 =
01152             *(static_cast<const array_t<float>*>(c1));
01153         const ibis::array_t<float>& v2 =
01154             *(static_cast<const array_t<float>*>(c2));
01155         float tmp = 0;
01156         switch (agg) {
01157         default:
01158             break;
01159         case ibis::selectClause::CNT:
01160         case ibis::selectClause::SUM:
01161             tmp = v1[i1] + v2[i2];
01162             break;
01163         case ibis::selectClause::MIN:
01164             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
01165             break;
01166         case ibis::selectClause::MAX:
01167             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
01168             break;
01169         }
01170         v0.push_back(tmp);
01171         break;}
01172     case ibis::DOUBLE: {
01173         ibis::array_t<double>& v0 =
01174             *(static_cast<array_t<double>*>(buffer));
01175         const ibis::array_t<double>& v1 =
01176             *(static_cast<const array_t<double>*>(c1));
01177         const ibis::array_t<double>& v2 =
01178             *(static_cast<const array_t<double>*>(c2));
01179         double tmp = 0;
01180         switch (agg) {
01181         default:
01182             break;
01183         case ibis::selectClause::CNT:
01184         case ibis::selectClause::SUM:
01185             tmp = v1[i1] + v2[i2];
01186             break;
01187         case ibis::selectClause::MIN:
01188             tmp = (v1[i1] <= v2[i2] ? v1[i1] : v2[i2]);
01189             break;
01190         case ibis::selectClause::MAX:
01191             tmp = (v1[i1] >= v2[i2] ? v1[i1] : v2[i2]);
01192             break;
01193         }
01194         v0.push_back(tmp);
01195         break;}
01196     }
01197 } // ibis::bord::column::append
01198 
01199 inline int ibis::bord::cursor::fetch() {
01200     ++ curRow;
01201     return (0 - (curRow >= (int64_t) tab.nRows()));
01202 } // ibis::bord::cursor::fetch
01203 
01204 inline int ibis::bord::cursor::fetch(uint64_t irow) {
01205     if (irow < tab.nRows()) {
01206         curRow = static_cast<int64_t>(irow);
01207         return 0;
01208     }
01209     else {
01210         return -1;
01211     }
01212 } // ibis::bord::cursor::fetch
01213 
01214 inline int ibis::bord::cursor::fetch(ibis::table::row& res) {
01215     ++ curRow;
01216     if ((uint64_t) curRow < tab.nRows()) {
01217         fillRow(res);
01218         return 0;
01219     }
01220     else {
01221         return -1;
01222     }
01223 } // ibis::bord::cursor::fetch
01224 
01225 inline int ibis::bord::cursor::fetch(uint64_t irow, ibis::table::row& res) {
01226     if (irow < tab.nRows()) {
01227         curRow = static_cast<int64_t>(irow);
01228         fillRow(res);
01229         return 0;
01230     }
01231     else {
01232         return -1;
01233     }
01234 } // ibis::bord::cursor::fetch
01235 
01236 inline int
01237 ibis::bord::cursor::dumpIJ(std::ostream& out, uint32_t i,
01238                            uint32_t j) const {
01239     if (buffer[j].cval == 0) return -1;
01240 
01241     switch (buffer[j].ctype) {
01242     case ibis::BYTE: {
01243         const array_t<const signed char>* vals =
01244             static_cast<const array_t<const signed char>*>(buffer[j].cval);
01245         out << (int) ((*vals)[i]);
01246         break;}
01247     case ibis::UBYTE: {
01248         const array_t<const unsigned char>* vals =
01249             static_cast<const array_t<const unsigned char>*>(buffer[j].cval);
01250         out << (unsigned int) ((*vals)[i]);
01251         break;}
01252     case ibis::SHORT: {
01253         const array_t<const int16_t>* vals =
01254             static_cast<const array_t<const int16_t>*>(buffer[j].cval);
01255         out << (*vals)[i];
01256         break;}
01257     case ibis::USHORT: {
01258         const array_t<const uint16_t>* vals =
01259             static_cast<const array_t<const uint16_t>*>(buffer[j].cval);
01260         out << (*vals)[i];
01261         break;}
01262     case ibis::INT: {
01263         const array_t<const int32_t>* vals =
01264             static_cast<const array_t<const int32_t>*>(buffer[j].cval);
01265         out << (*vals)[i];
01266         break;}
01267     case ibis::UINT: {
01268         const array_t<const uint32_t>* vals =
01269             static_cast<const array_t<const uint32_t>*>(buffer[j].cval);
01270         out << (*vals)[i];
01271         break;}
01272     case ibis::LONG: {
01273         const array_t<const int64_t>* vals =
01274             static_cast<const array_t<const int64_t>*>(buffer[j].cval);
01275         out << (*vals)[i];
01276         break;}
01277     case ibis::ULONG: {
01278         const array_t<const uint64_t>* vals =
01279             static_cast<const array_t<const uint64_t>*>(buffer[j].cval);
01280         out << (*vals)[i];
01281         break;}
01282     case ibis::FLOAT: {
01283         const array_t<const float>* vals =
01284             static_cast<const array_t<const float>*>(buffer[j].cval);
01285         out << (*vals)[i];
01286         break;}
01287     case ibis::DOUBLE: {
01288         const array_t<const double>* vals =
01289             static_cast<const array_t<const double>*>(buffer[j].cval);
01290         out << (*vals)[i];
01291         break;}
01292     case ibis::TEXT:
01293     case ibis::CATEGORY: {
01294         const std::vector<std::string>* vals =
01295             static_cast<const std::vector<std::string>*>(buffer[j].cval);
01296         out << '"' << (*vals)[i] << '"';
01297         break;}
01298     default: {
01299         return -2;}
01300     }
01301     return 0;
01302 } // ibis::bord::cursor::dumpIJ
01303 
01304 inline int
01305 ibis::bord::cursor::getColumnAsByte(const char* cn, char& val) const {
01306     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01307         return -1;
01308     bufferMap::const_iterator it = bufmap.find(cn);
01309     if (it != bufmap.end())
01310         return getColumnAsByte((*it).second, val);
01311     else
01312         return -2;
01313 } // ibis::bord::cursor::getColumnAsByte
01314 
01315 inline int
01316 ibis::bord::cursor::getColumnAsUByte(const char* cn,
01317                                      unsigned char& val) const {
01318     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01319         return -1;
01320     bufferMap::const_iterator it = bufmap.find(cn);
01321     if (it != bufmap.end())
01322         return getColumnAsUByte((*it).second, val);
01323     else
01324         return -2;
01325 } // ibis::bord::cursor::getColumnAsUByte
01326 
01327 inline int
01328 ibis::bord::cursor::getColumnAsShort(const char* cn, int16_t& val) const {
01329     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01330         return -1;
01331     bufferMap::const_iterator it = bufmap.find(cn);
01332     if (it != bufmap.end())
01333         return getColumnAsShort((*it).second, val);
01334     else
01335         return -2;
01336 } // ibis::bord::cursor::getColumnAsShort
01337 
01338 inline int
01339 ibis::bord::cursor::getColumnAsUShort(const char* cn, uint16_t& val) const {
01340     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01341         return -1;
01342     bufferMap::const_iterator it = bufmap.find(cn);
01343     if (it != bufmap.end())
01344         return getColumnAsUShort((*it).second, val);
01345     else
01346         return -2;
01347 } // ibis::bord::cursor::getColumnAsUShort
01348 
01349 inline int
01350 ibis::bord::cursor::getColumnAsInt(const char* cn, int32_t& val) const {
01351     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01352         return -1;
01353     bufferMap::const_iterator it = bufmap.find(cn);
01354     if (it != bufmap.end())
01355         return getColumnAsInt((*it).second, val);
01356     else
01357         return -2;
01358 } // ibis::bord::cursor::getColumnAsInt
01359 
01360 inline int
01361 ibis::bord::cursor::getColumnAsUInt(const char* cn, uint32_t& val) const {
01362     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01363         return -1;
01364     bufferMap::const_iterator it = bufmap.find(cn);
01365     if (it != bufmap.end())
01366         return getColumnAsUInt((*it).second, val);
01367     else
01368         return -2;
01369 } // ibis::bord::cursor::getColumnAsUInt
01370 
01371 inline int
01372 ibis::bord::cursor::getColumnAsLong(const char* cn, int64_t& val) const {
01373     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01374         return -1;
01375     bufferMap::const_iterator it = bufmap.find(cn);
01376     if (it != bufmap.end())
01377         return getColumnAsLong((*it).second, val);
01378     else
01379         return -2;
01380 } // ibis::bord::cursor::getColumnAsLong
01381 
01382 inline int
01383 ibis::bord::cursor::getColumnAsULong(const char* cn, uint64_t& val) const {
01384     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01385         return -1;
01386     bufferMap::const_iterator it = bufmap.find(cn);
01387     if (it != bufmap.end())
01388         return getColumnAsULong((*it).second, val);
01389     else
01390         return -2;
01391 } // ibis::bord::cursor::getColumnAsULong
01392 
01393 inline int
01394 ibis::bord::cursor::getColumnAsFloat(const char* cn, float& val) const {
01395     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01396         return -1;
01397     bufferMap::const_iterator it = bufmap.find(cn);
01398     if (it != bufmap.end())
01399         return getColumnAsFloat((*it).second, val);
01400     else
01401         return -2;
01402 } // ibis::bord::cursor::getColumnAsFloat
01403 
01404 inline int
01405 ibis::bord::cursor::getColumnAsDouble(const char* cn, double& val) const {
01406     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01407         return -1;
01408     bufferMap::const_iterator it = bufmap.find(cn);
01409     if (it != bufmap.end())
01410         return getColumnAsDouble((*it).second, val);
01411     else
01412         return -2;
01413 } // ibis::bord::cursor::getColumnAsDouble
01414 
01415 inline int
01416 ibis::bord::cursor::getColumnAsString(const char* cn,
01417                                       std::string& val) const {
01418     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
01419         return -1;
01420     bufferMap::const_iterator it = bufmap.find(cn);
01421     if (it != bufmap.end())
01422         return getColumnAsString((*it).second, val);
01423     else
01424         return -2;
01425 } // ibis::bord::cursor::getColumnAsString
01426 #endif // IBIS_BORD_H

Make It A Bit Faster
Contact us
Disclaimers
FastBit source code
FastBit mailing list archive