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

00001 // File: $Id$
00002 // Author: John Wu <John.Wu at ACM.org>
00003 // Copyright 2008-2009 the Regents of the University of California
00004 #ifndef IBIS_JOININ_H
00005 #define IBIS_JOININ_H
00006 
00012 #include "join.h"       // ibis::join
00013 
00014 namespace ibis {
00015     class joinIN; // forward definition
00016 } // namespace ibis
00017 
00019 class ibis::joinIN : public ibis::join {
00020 public:
00021     joinIN(const ibis::part& partr, const ibis::part& parts,
00022            const char* colname, const char* condr, const char* conds);
00023     virtual ~joinIN();
00024 
00025     virtual void estimate(uint64_t& nmin, uint64_t& nmax);
00026     virtual int64_t evaluate();
00027 
00028     virtual ibis::join::result*
00029     select(const std::vector<const char*>& colnames);
00030 
00031     class result;
00032 
00033 protected:
00034     const ibis::part& R_;
00035     const ibis::part& S_;
00036     const ibis::column *colR_;
00037     const ibis::column *colS_;
00038     ibis::bitvector maskR_;
00039     ibis::bitvector maskS_;
00040     array_t<uint32_t> *orderR_;
00041     array_t<uint32_t> *orderS_;
00042     void *valR_;
00043     void *valS_;
00044     std::string desc_;
00045     int64_t nrows;
00046 
00047     friend class ibis::joinIN::result;
00048     static void freeBuffer(void* buffer, ibis::TYPE_T type);
00049 
00050 private:
00051     joinIN(const joinIN&); // no copying
00052     joinIN& operator=(const joinIN&); // no assignment
00053 }; // class ibis::joinIN
00054 
00055 class ibis::joinIN::result : public ibis::join::result {
00056 public:
00057     virtual ~result();
00058     result(const ibis::joinIN& jin, const std::vector<const char*>& colnames);
00059 
00060     virtual uint64_t nRows() const {return jin_.nrows;}
00061     virtual uint32_t nColumns() const {return 0;}
00062 
00063     virtual std::vector<std::string> columnNames() const;
00064     virtual ibis::table::typeList columnTypes() const;
00065     virtual void describe(std::ostream& out) const;
00066 
00067     virtual int fetch();
00068     virtual int dump(std::ostream& out, const char* del=", ") const;
00069 
00070     virtual int getColumnAsByte(const char* cname, char&) const;
00071     virtual int getColumnAsUByte(const char* cname, unsigned char&) const;
00072     virtual int getColumnAsShort(const char* cname, int16_t&) const;
00073     virtual int getColumnAsUShort(const char* cname, uint16_t&) const;
00074     virtual int getColumnAsInt(const char* cname, int32_t&) const;
00075     virtual int getColumnAsUInt(const char* cname, uint32_t&) const;
00076     virtual int getColumnAsLong(const char* cname, int64_t&) const;
00077     virtual int getColumnAsULong(const char* cname, uint64_t&) const;
00078     virtual int getColumnAsFloat(const char* cname, float&) const;
00079     virtual int getColumnAsDouble(const char* cname, double&) const;
00080     virtual int getColumnAsString(const char* cname, std::string&) const;
00081 
00082     virtual int getColumnAsByte(uint32_t cnum, char&) const;
00083     virtual int getColumnAsUByte(uint32_t cnum, unsigned char&) const;
00084     virtual int getColumnAsShort(uint32_t cnum, int16_t&) const;
00085     virtual int getColumnAsUShort(uint32_t cnum, uint16_t&) const;
00086     virtual int getColumnAsInt(uint32_t cnum, int32_t&) const;
00087     virtual int getColumnAsUInt(uint32_t cnum, uint32_t&) const;
00088     virtual int getColumnAsLong(uint32_t cnum, int64_t&) const;
00089     virtual int getColumnAsULong(uint32_t cnum, uint64_t&) const;
00090     virtual int getColumnAsFloat(uint32_t cnum, float&) const;
00091     virtual int getColumnAsDouble(uint32_t cnum, double&) const;
00092     virtual int getColumnAsString(uint32_t cnum, std::string&) const;
00093 
00094 protected:
00095     const ibis::joinIN& jin_;
00096     const uint32_t endR_, endS_;
00097     uint32_t currR_, currS_, blockR_, blockS_, startS_;
00098     std::vector<const ibis::column*> colR_, colS_;
00099     std::vector<ibis::TYPE_T> typeR_, typeS_;
00100     std::vector<void*> valR_, valS_;
00101     std::map<const char*, uint32_t, ibis::lessi> namesToPos;
00102     std::vector<uint32_t> ipToPos;
00103 
00104     template <typename T>
00105     int nextMatch(const array_t<T>& col1, const array_t<T>& col2);
00106     int stringMatch(const std::vector<std::string>& col1,
00107                     const std::vector<std::string>& col2);
00108     void dumpR(std::ostream& out, uint32_t ind) const;
00109     void dumpS(std::ostream& out, uint32_t ind) const;
00110 
00111 private:
00112     result(const result&); // no copying
00113     result& operator=(const result&); // no assignment
00114 }; // class ibis::joinIN::result
00115 
00116 inline int
00117 ibis::joinIN::result::getColumnAsByte(uint32_t cnum, char& val) const {
00118     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00119         return -1;
00120 
00121     int ierr = -2;
00122     uint32_t pos = ipToPos[cnum];
00123     if (pos < colR_.size()) {
00124         if (typeR_[pos] == ibis::BYTE && colR_[pos] != 0) {
00125             val = (*(static_cast<array_t<char>*>(valR_[pos])))
00126                 [(*jin_.orderR_)[currR_]];
00127             ierr = 0;
00128         }
00129     }
00130     else {
00131         pos -= colR_.size();
00132         if (typeS_[pos] == ibis::BYTE && colS_[pos] != 0) {
00133             val = (*(static_cast<array_t<char>*>(valS_[pos])))
00134                 [(*jin_.orderS_)[currS_]];
00135             ierr = 0;
00136         }
00137     }
00138     return ierr;
00139 } // ibis::joinIN::result::getColumnAsByte
00140 
00141 inline int
00142 ibis::joinIN::result::getColumnAsUByte(uint32_t cnum, unsigned char& val) const {
00143     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00144         return -1;
00145 
00146     int ierr = -2;
00147     uint32_t pos = ipToPos[cnum];
00148     if (pos < colR_.size()) {
00149         if (typeR_[pos] == ibis::UBYTE && colR_[pos] != 0) {
00150             val = (*(static_cast<array_t<unsigned char>*>(valR_[pos])))
00151                 [(*jin_.orderR_)[currR_]];
00152             ierr = 0;
00153         }
00154     }
00155     else {
00156         pos -= colR_.size();
00157         if (typeS_[pos] == ibis::UBYTE && colS_[pos] != 0) {
00158             val = (*(static_cast<array_t<unsigned char>*>(valS_[pos])))
00159                 [(*jin_.orderS_)[currS_]];
00160             ierr = 0;
00161         }
00162     }
00163     return ierr;
00164 } // ibis::joinIN::result::getColumnAsUByte
00165 
00166 inline int
00167 ibis::joinIN::result::getColumnAsShort(uint32_t cnum, int16_t& val) const {
00168     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00169         return -1;
00170 
00171     int ierr = -2;
00172     uint32_t pos = ipToPos[cnum];
00173     if (pos < colR_.size()) {
00174         if (colR_[pos] != 0) {
00175             switch (typeR_[pos]) {
00176             default: break;
00177             case ibis::BYTE:
00178                 val = (*(static_cast<array_t<char>*>(valR_[pos])))
00179                     [(*jin_.orderR_)[currR_]];
00180                 ierr = 0;
00181                 break;
00182             case ibis::UBYTE:
00183                 val = (*(static_cast<array_t<unsigned char>*>(valR_[pos])))
00184                     [(*jin_.orderR_)[currR_]];
00185                 ierr = 0;
00186                 break;
00187             case ibis::SHORT:
00188                 val = (*(static_cast<array_t<int16_t>*>(valR_[pos])))
00189                     [(*jin_.orderR_)[currR_]];
00190                 ierr = 0;
00191                 break;
00192             }
00193         }
00194     }
00195     else {
00196         pos -= colR_.size();
00197         if (colS_[pos] != 0) {
00198             switch (typeS_[pos]) {
00199             default: break;
00200             case ibis::BYTE:
00201                 val = (*(static_cast<array_t<char>*>(valS_[pos])))
00202                     [(*jin_.orderS_)[currS_]];
00203                 ierr = 0;
00204                 break;
00205             case ibis::UBYTE:
00206                 val = (*(static_cast<array_t<unsigned char>*>(valS_[pos])))
00207                     [(*jin_.orderS_)[currS_]];
00208                 ierr = 0;
00209                 break;
00210             case ibis::SHORT:
00211                 val = (*(static_cast<array_t<int16_t>*>(valS_[pos])))
00212                     [(*jin_.orderS_)[currS_]];
00213                 ierr = 0;
00214                 break;
00215             }
00216         }
00217     }
00218     return ierr;
00219 } // ibis::joinIN::result::getColumnAsShort
00220 
00221 inline int
00222 ibis::joinIN::result::getColumnAsUShort(uint32_t cnum, uint16_t& val) const {
00223     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00224         return -1;
00225 
00226     int ierr = -2;
00227     uint32_t pos = ipToPos[cnum];
00228     if (pos < colR_.size()) {
00229         if (colR_[pos] != 0) {
00230             switch (typeR_[pos]) {
00231             default: break;
00232             case ibis::BYTE:
00233                 val = (*(static_cast<array_t<char>*>(valR_[pos])))
00234                     [(*jin_.orderR_)[currR_]];
00235                 ierr = 0;
00236                 break;
00237             case ibis::UBYTE:
00238                 val = (*(static_cast<array_t<unsigned char>*>(valR_[pos])))
00239                     [(*jin_.orderR_)[currR_]];
00240                 ierr = 0;
00241                 break;
00242             case ibis::USHORT:
00243                 val = (*(static_cast<array_t<uint16_t>*>(valR_[pos])))
00244                     [(*jin_.orderR_)[currR_]];
00245                 ierr = 0;
00246                 break;
00247             }
00248         }
00249     }
00250     else {
00251         pos -= colR_.size();
00252         if (colS_[pos] != 0) {
00253             switch (typeS_[pos]) {
00254             default: break;
00255             case ibis::BYTE:
00256                 val = (*(static_cast<array_t<char>*>(valS_[pos])))
00257                     [(*jin_.orderS_)[currS_]];
00258                 ierr = 0;
00259                 break;
00260             case ibis::UBYTE:
00261                 val = (*(static_cast<array_t<unsigned char>*>(valS_[pos])))
00262                     [(*jin_.orderS_)[currS_]];
00263                 ierr = 0;
00264                 break;
00265             case ibis::USHORT:
00266                 val = (*(static_cast<array_t<uint16_t>*>(valS_[pos])))
00267                     [(*jin_.orderS_)[currS_]];
00268                 ierr = 0;
00269                 break;
00270             }
00271         }
00272     }
00273     return ierr;
00274 } // ibis::joinIN::result::getColumnAsUShort
00275 
00276 inline int
00277 ibis::joinIN::result::getColumnAsInt(uint32_t cnum, int32_t& val) const {
00278     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00279         return -1;
00280 
00281     int ierr = -2;
00282     uint32_t pos = ipToPos[cnum];
00283     if (pos < colR_.size()) {
00284         if (colR_[pos] != 0) {
00285             switch (typeR_[pos]) {
00286             default: break;
00287             case ibis::BYTE:
00288                 val = (*(static_cast<array_t<char>*>(valR_[pos])))
00289                     [(*jin_.orderR_)[currR_]];
00290                 ierr = 0;
00291                 break;
00292             case ibis::UBYTE:
00293                 val = (*(static_cast<array_t<unsigned char>*>(valR_[pos])))
00294                     [(*jin_.orderR_)[currR_]];
00295                 ierr = 0;
00296                 break;
00297             case ibis::SHORT:
00298                 val = (*(static_cast<array_t<int16_t>*>(valR_[pos])))
00299                     [(*jin_.orderR_)[currR_]];
00300                 ierr = 0;
00301                 break;
00302             case ibis::USHORT:
00303                 val = (*(static_cast<array_t<uint16_t>*>(valR_[pos])))
00304                     [(*jin_.orderR_)[currR_]];
00305                 ierr = 0;
00306                 break;
00307             case ibis::INT:
00308                 val = (*(static_cast<array_t<int32_t>*>(valR_[pos])))
00309                     [(*jin_.orderR_)[currR_]];
00310                 ierr = 0;
00311                 break;
00312             }
00313         }
00314     }
00315     else {
00316         pos -= colR_.size();
00317         if (colS_[pos] != 0) {
00318             switch (typeS_[pos]) {
00319             default: break;
00320             case ibis::BYTE:
00321                 val = (*(static_cast<array_t<char>*>(valS_[pos])))
00322                     [(*jin_.orderS_)[currS_]];
00323                 ierr = 0;
00324                 break;
00325             case ibis::UBYTE:
00326                 val = (*(static_cast<array_t<unsigned char>*>(valS_[pos])))
00327                     [(*jin_.orderS_)[currS_]];
00328                 ierr = 0;
00329                 break;
00330             case ibis::SHORT:
00331                 val = (*(static_cast<array_t<int16_t>*>(valS_[pos])))
00332                     [(*jin_.orderS_)[currS_]];
00333                 ierr = 0;
00334                 break;
00335             case ibis::USHORT:
00336                 val = (*(static_cast<array_t<uint16_t>*>(valS_[pos])))
00337                     [(*jin_.orderS_)[currS_]];
00338                 ierr = 0;
00339                 break;
00340             case ibis::INT:
00341                 val = (*(static_cast<array_t<int32_t>*>(valS_[pos])))
00342                     [(*jin_.orderS_)[currS_]];
00343                 ierr = 0;
00344                 break;
00345             }
00346         }
00347     }
00348     return ierr;
00349 } // ibis::joinIN::result::getColumnAsInt
00350 
00351 inline int
00352 ibis::joinIN::result::getColumnAsUInt(uint32_t cnum, uint32_t& val) const {
00353     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00354         return -1;
00355 
00356     int ierr = -2;
00357     uint32_t pos = ipToPos[cnum];
00358     if (pos < colR_.size()) {
00359         if (colR_[pos] != 0) {
00360             switch (typeR_[pos]) {
00361             default: break;
00362             case ibis::BYTE:
00363                 val = (*(static_cast<array_t<char>*>(valR_[pos])))
00364                     [(*jin_.orderR_)[currR_]];
00365                 ierr = 0;
00366                 break;
00367             case ibis::UBYTE:
00368                 val = (*(static_cast<array_t<unsigned char>*>(valR_[pos])))
00369                     [(*jin_.orderR_)[currR_]];
00370                 ierr = 0;
00371                 break;
00372             case ibis::SHORT:
00373                 val = (*(static_cast<array_t<int16_t>*>(valR_[pos])))
00374                     [(*jin_.orderR_)[currR_]];
00375                 ierr = 0;
00376                 break;
00377             case ibis::USHORT:
00378                 val = (*(static_cast<array_t<uint16_t>*>(valR_[pos])))
00379                     [(*jin_.orderR_)[currR_]];
00380                 ierr = 0;
00381                 break;
00382             case ibis::UINT:
00383                 val = (*(static_cast<array_t<uint32_t>*>(valR_[pos])))
00384                     [(*jin_.orderR_)[currR_]];
00385                 ierr = 0;
00386                 break;
00387             }
00388         }
00389     }
00390     else {
00391         pos -= colR_.size();
00392         if (colS_[pos] != 0) {
00393             switch (typeS_[pos]) {
00394             default: break;
00395             case ibis::BYTE:
00396                 val = (*(static_cast<array_t<char>*>(valS_[pos])))
00397                     [(*jin_.orderS_)[currS_]];
00398                 ierr = 0;
00399                 break;
00400             case ibis::UBYTE:
00401                 val = (*(static_cast<array_t<unsigned char>*>(valS_[pos])))
00402                     [(*jin_.orderS_)[currS_]];
00403                 ierr = 0;
00404                 break;
00405             case ibis::SHORT:
00406                 val = (*(static_cast<array_t<int16_t>*>(valS_[pos])))
00407                     [(*jin_.orderS_)[currS_]];
00408                 ierr = 0;
00409                 break;
00410             case ibis::USHORT:
00411                 val = (*(static_cast<array_t<uint16_t>*>(valS_[pos])))
00412                     [(*jin_.orderS_)[currS_]];
00413                 ierr = 0;
00414                 break;
00415             case ibis::UINT:
00416                 val = (*(static_cast<array_t<uint32_t>*>(valS_[pos])))
00417                     [(*jin_.orderS_)[currS_]];
00418                 ierr = 0;
00419                 break;
00420             }
00421         }
00422     }
00423     return ierr;
00424 } // ibis::joinIN::result::getColumnAsUInt
00425 
00426 inline int
00427 ibis::joinIN::result::getColumnAsLong(uint32_t cnum, int64_t& val) const {
00428     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00429         return -1;
00430 
00431     int ierr = -2;
00432     uint32_t pos = ipToPos[cnum];
00433     if (pos < colR_.size()) {
00434         if (colR_[pos] != 0) {
00435             switch (typeR_[pos]) {
00436             default: break;
00437             case ibis::BYTE:
00438                 val = (*(static_cast<array_t<char>*>(valR_[pos])))
00439                     [(*jin_.orderR_)[currR_]];
00440                 ierr = 0;
00441                 break;
00442             case ibis::UBYTE:
00443                 val = (*(static_cast<array_t<unsigned char>*>(valR_[pos])))
00444                     [(*jin_.orderR_)[currR_]];
00445                 ierr = 0;
00446                 break;
00447             case ibis::SHORT:
00448                 val = (*(static_cast<array_t<int16_t>*>(valR_[pos])))
00449                     [(*jin_.orderR_)[currR_]];
00450                 ierr = 0;
00451                 break;
00452             case ibis::USHORT:
00453                 val = (*(static_cast<array_t<uint16_t>*>(valR_[pos])))
00454                     [(*jin_.orderR_)[currR_]];
00455                 ierr = 0;
00456                 break;
00457             case ibis::INT:
00458                 val = (*(static_cast<array_t<int32_t>*>(valR_[pos])))
00459                     [(*jin_.orderR_)[currR_]];
00460                 ierr = 0;
00461                 break;
00462             case ibis::UINT:
00463                 val = (*(static_cast<array_t<uint32_t>*>(valR_[pos])))
00464                     [(*jin_.orderR_)[currR_]];
00465                 ierr = 0;
00466                 break;
00467             case ibis::LONG:
00468                 val = (*(static_cast<array_t<int64_t>*>(valR_[pos])))
00469                     [(*jin_.orderR_)[currR_]];
00470                 ierr = 0;
00471                 break;
00472             }
00473         }
00474     }
00475     else {
00476         pos -= colR_.size();
00477         if (colS_[pos] != 0) {
00478             switch (typeS_[pos]) {
00479             default: break;
00480             case ibis::BYTE:
00481                 val = (*(static_cast<array_t<char>*>(valS_[pos])))
00482                     [(*jin_.orderS_)[currS_]];
00483                 ierr = 0;
00484                 break;
00485             case ibis::UBYTE:
00486                 val = (*(static_cast<array_t<unsigned char>*>(valS_[pos])))
00487                     [(*jin_.orderS_)[currS_]];
00488                 ierr = 0;
00489                 break;
00490             case ibis::SHORT:
00491                 val = (*(static_cast<array_t<int16_t>*>(valS_[pos])))
00492                     [(*jin_.orderS_)[currS_]];
00493                 ierr = 0;
00494                 break;
00495             case ibis::USHORT:
00496                 val = (*(static_cast<array_t<uint16_t>*>(valS_[pos])))
00497                     [(*jin_.orderS_)[currS_]];
00498                 ierr = 0;
00499                 break;
00500             case ibis::INT:
00501                 val = (*(static_cast<array_t<int32_t>*>(valS_[pos])))
00502                     [(*jin_.orderS_)[currS_]];
00503                 ierr = 0;
00504                 break;
00505             case ibis::UINT:
00506                 val = (*(static_cast<array_t<uint32_t>*>(valS_[pos])))
00507                     [(*jin_.orderS_)[currS_]];
00508                 ierr = 0;
00509                 break;
00510             case ibis::LONG:
00511                 val = (*(static_cast<array_t<int64_t>*>(valS_[pos])))
00512                     [(*jin_.orderS_)[currS_]];
00513                 ierr = 0;
00514                 break;
00515             }
00516         }
00517     }
00518     return ierr;
00519 } // ibis::joinIN::result::getColumnAsLong
00520 
00521 inline int
00522 ibis::joinIN::result::getColumnAsULong(uint32_t cnum, uint64_t& val) const {
00523     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00524         return -1;
00525 
00526     int ierr = -2;
00527     uint32_t pos = ipToPos[cnum];
00528     if (pos < colR_.size()) {
00529         if (colR_[pos] != 0) {
00530             switch (typeR_[pos]) {
00531             default: break;
00532             case ibis::BYTE:
00533                 val = (*(static_cast<array_t<char>*>(valR_[pos])))
00534                     [(*jin_.orderR_)[currR_]];
00535                 ierr = 0;
00536                 break;
00537             case ibis::UBYTE:
00538                 val = (*(static_cast<array_t<unsigned char>*>(valR_[pos])))
00539                     [(*jin_.orderR_)[currR_]];
00540                 ierr = 0;
00541                 break;
00542             case ibis::SHORT:
00543                 val = (*(static_cast<array_t<int16_t>*>(valR_[pos])))
00544                     [(*jin_.orderR_)[currR_]];
00545                 ierr = 0;
00546                 break;
00547             case ibis::USHORT:
00548                 val = (*(static_cast<array_t<uint16_t>*>(valR_[pos])))
00549                     [(*jin_.orderR_)[currR_]];
00550                 ierr = 0;
00551                 break;
00552             case ibis::INT:
00553                 val = (*(static_cast<array_t<int32_t>*>(valR_[pos])))
00554                     [(*jin_.orderR_)[currR_]];
00555                 ierr = 0;
00556                 break;
00557             case ibis::UINT:
00558                 val = (*(static_cast<array_t<uint32_t>*>(valR_[pos])))
00559                     [(*jin_.orderR_)[currR_]];
00560                 ierr = 0;
00561                 break;
00562             case ibis::ULONG:
00563                 val = (*(static_cast<array_t<uint64_t>*>(valR_[pos])))
00564                     [(*jin_.orderR_)[currR_]];
00565                 ierr = 0;
00566                 break;
00567             }
00568         }
00569     }
00570     else {
00571         pos -= colR_.size();
00572         if (colS_[pos] != 0) {
00573             switch (typeS_[pos]) {
00574             default: break;
00575             case ibis::BYTE:
00576                 val = (*(static_cast<array_t<char>*>(valS_[pos])))
00577                     [(*jin_.orderS_)[currS_]];
00578                 ierr = 0;
00579                 break;
00580             case ibis::UBYTE:
00581                 val = (*(static_cast<array_t<unsigned char>*>(valS_[pos])))
00582                     [(*jin_.orderS_)[currS_]];
00583                 ierr = 0;
00584                 break;
00585             case ibis::SHORT:
00586                 val = (*(static_cast<array_t<int16_t>*>(valS_[pos])))
00587                     [(*jin_.orderS_)[currS_]];
00588                 ierr = 0;
00589                 break;
00590             case ibis::USHORT:
00591                 val = (*(static_cast<array_t<uint16_t>*>(valS_[pos])))
00592                     [(*jin_.orderS_)[currS_]];
00593                 ierr = 0;
00594                 break;
00595             case ibis::INT:
00596                 val = (*(static_cast<array_t<int32_t>*>(valS_[pos])))
00597                     [(*jin_.orderS_)[currS_]];
00598                 ierr = 0;
00599                 break;
00600             case ibis::UINT:
00601                 val = (*(static_cast<array_t<uint32_t>*>(valS_[pos])))
00602                     [(*jin_.orderS_)[currS_]];
00603                 ierr = 0;
00604                 break;
00605             case ibis::ULONG:
00606                 val = (*(static_cast<array_t<uint64_t>*>(valS_[pos])))
00607                     [(*jin_.orderS_)[currS_]];
00608                 ierr = 0;
00609                 break;
00610             }
00611         }
00612     }
00613     return ierr;
00614 } // ibis::joinIN::result::getColumnAsULong
00615 
00616 inline int
00617 ibis::joinIN::result::getColumnAsFloat(uint32_t cnum, float& val) const {
00618     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00619         return -1;
00620 
00621     int ierr = -2;
00622     uint32_t pos = ipToPos[cnum];
00623     if (pos < colR_.size()) {
00624         if (colR_[pos] != 0) {
00625             switch (typeR_[pos]) {
00626             default: break;
00627             case ibis::BYTE:
00628                 val = (*(static_cast<array_t<char>*>(valR_[pos])))
00629                     [(*jin_.orderR_)[currR_]];
00630                 ierr = 0;
00631                 break;
00632             case ibis::UBYTE:
00633                 val = (*(static_cast<array_t<unsigned char>*>(valR_[pos])))
00634                     [(*jin_.orderR_)[currR_]];
00635                 ierr = 0;
00636                 break;
00637             case ibis::SHORT:
00638                 val = (*(static_cast<array_t<int16_t>*>(valR_[pos])))
00639                     [(*jin_.orderR_)[currR_]];
00640                 ierr = 0;
00641                 break;
00642             case ibis::USHORT:
00643                 val = (*(static_cast<array_t<uint16_t>*>(valR_[pos])))
00644                     [(*jin_.orderR_)[currR_]];
00645                 ierr = 0;
00646                 break;
00647             case ibis::FLOAT:
00648                 val = (*(static_cast<array_t<float>*>(valR_[pos])))
00649                     [(*jin_.orderR_)[currR_]];
00650                 ierr = 0;
00651                 break;
00652             }
00653         }
00654     }
00655     else {
00656         pos -= colR_.size();
00657         if (colS_[pos] != 0) {
00658             switch (typeS_[pos]) {
00659             default: break;
00660             case ibis::BYTE:
00661                 val = (*(static_cast<array_t<char>*>(valS_[pos])))
00662                     [(*jin_.orderS_)[currS_]];
00663                 ierr = 0;
00664                 break;
00665             case ibis::UBYTE:
00666                 val = (*(static_cast<array_t<unsigned char>*>(valS_[pos])))
00667                     [(*jin_.orderS_)[currS_]];
00668                 ierr = 0;
00669                 break;
00670             case ibis::SHORT:
00671                 val = (*(static_cast<array_t<int16_t>*>(valS_[pos])))
00672                     [(*jin_.orderS_)[currS_]];
00673                 ierr = 0;
00674                 break;
00675             case ibis::USHORT:
00676                 val = (*(static_cast<array_t<uint16_t>*>(valS_[pos])))
00677                     [(*jin_.orderS_)[currS_]];
00678                 ierr = 0;
00679                 break;
00680             case ibis::FLOAT:
00681                 val = (*(static_cast<array_t<float>*>(valS_[pos])))
00682                     [(*jin_.orderS_)[currS_]];
00683                 ierr = 0;
00684                 break;
00685             }
00686         }
00687     }
00688     return ierr;
00689 } // ibis::joinIN::result::getColumnAsFloat
00690 
00691 inline int
00692 ibis::joinIN::result::getColumnAsDouble(uint32_t cnum, double& val) const {
00693     if (currR_ >= blockR_ || currS_ >= blockS_ || cnum >= ipToPos.size())
00694         return -1;
00695 
00696     int ierr = -2;
00697     uint32_t pos = ipToPos[cnum];
00698     if (pos < colR_.size()) {
00699         if (colR_[pos] != 0) {
00700             switch (typeR_[pos]) {
00701             default: break;
00702             case ibis::BYTE:
00703                 val = (*(static_cast<array_t<char>*>(valR_[pos])))
00704                     [(*jin_.orderR_)[currR_]];
00705                 ierr = 0;
00706                 break;
00707             case ibis::UBYTE:
00708                 val = (*(static_cast<array_t<unsigned char>*>(valR_[pos])))
00709                     [(*jin_.orderR_)[currR_]];
00710                 ierr = 0;
00711                 break;
00712             case ibis::SHORT:
00713                 val = (*(static_cast<array_t<int16_t>*>(valR_[pos])))
00714                     [(*jin_.orderR_)[currR_]];
00715                 ierr = 0;
00716                 break;
00717             case ibis::USHORT:
00718                 val = (*(static_cast<array_t<uint16_t>*>(valR_[pos])))
00719                     [(*jin_.orderR_)[currR_]];
00720                 ierr = 0;
00721                 break;
00722             case ibis::INT:
00723                 val = (*(static_cast<array_t<int32_t>*>(valR_[pos])))
00724                     [(*jin_.orderR_)[currR_]];
00725                 ierr = 0;
00726                 break;
00727             case ibis::UINT:
00728                 val = (*(static_cast<array_t<uint32_t>*>(valR_[pos])))
00729                     [(*jin_.orderR_)[currR_]];
00730                 ierr = 0;
00731                 break;
00732             case ibis::FLOAT:
00733                 val = (*(static_cast<array_t<float>*>(valR_[pos])))
00734                     [(*jin_.orderR_)[currR_]];
00735                 ierr = 0;
00736                 break;
00737             case ibis::DOUBLE:
00738                 val = (*(static_cast<array_t<double>*>(valR_[pos])))
00739                     [(*jin_.orderR_)[currR_]];
00740                 ierr = 0;
00741                 break;
00742             }
00743         }
00744     }
00745     else {
00746         pos -= colR_.size();
00747         if (colS_[pos] != 0) {
00748             switch (typeS_[pos]) {
00749             default: break;
00750             case ibis::BYTE:
00751                 val = (*(static_cast<array_t<char>*>(valS_[pos])))
00752                     [(*jin_.orderS_)[currS_]];
00753                 ierr = 0;
00754                 break;
00755             case ibis::UBYTE:
00756                 val = (*(static_cast<array_t<unsigned char>*>(valS_[pos])))
00757                     [(*jin_.orderS_)[currS_]];
00758                 ierr = 0;
00759                 break;
00760             case ibis::SHORT:
00761                 val = (*(static_cast<array_t<int16_t>*>(valS_[pos])))
00762                     [(*jin_.orderS_)[currS_]];
00763                 ierr = 0;
00764                 break;
00765             case ibis::USHORT:
00766                 val = (*(static_cast<array_t<uint16_t>*>(valS_[pos])))
00767                     [(*jin_.orderS_)[currS_]];
00768                 ierr = 0;
00769                 break;
00770             case ibis::INT:
00771                 val = (*(static_cast<array_t<int32_t>*>(valS_[pos])))
00772                     [(*jin_.orderS_)[currS_]];
00773                 ierr = 0;
00774                 break;
00775             case ibis::UINT:
00776                 val = (*(static_cast<array_t<uint32_t>*>(valS_[pos])))
00777                     [(*jin_.orderS_)[currS_]];
00778                 ierr = 0;
00779                 break;
00780             case ibis::FLOAT:
00781                 val = (*(static_cast<array_t<float>*>(valS_[pos])))
00782                     [(*jin_.orderS_)[currS_]];
00783                 ierr = 0;
00784                 break;
00785             case ibis::DOUBLE:
00786                 val = (*(static_cast<array_t<double>*>(valS_[pos])))
00787                     [(*jin_.orderS_)[currS_]];
00788                 ierr = 0;
00789                 break;
00790             }
00791         }
00792     }
00793     return ierr;
00794 } // ibis::joinIN::result::getColumnAsDouble
00795 
00796 inline void
00797 ibis::joinIN::result::dumpR(std::ostream& out, uint32_t ind) const {
00798     if (colR_[ind] == 0) return;
00799     switch (typeR_[ind]) {
00800     default: break;
00801     case ibis::BYTE:
00802         out << (int)(*(static_cast<const array_t<char>*>(valR_[ind])))
00803             [(*jin_.orderR_)[currR_]];
00804         break;
00805     case ibis::UBYTE:
00806         out << (int)(*(static_cast<const array_t<unsigned char>*>(valR_[ind])))
00807             [(*jin_.orderR_)[currR_]];
00808         break;
00809     case ibis::SHORT:
00810         out << (*(static_cast<const array_t<int16_t>*>(valR_[ind])))
00811             [(*jin_.orderR_)[currR_]];
00812         break;
00813     case ibis::USHORT:
00814         out << (*(static_cast<const array_t<uint16_t>*>(valR_[ind])))
00815             [(*jin_.orderR_)[currR_]];
00816         break;
00817     case ibis::INT:
00818         out << (*(static_cast<const array_t<int32_t>*>(valR_[ind])))
00819             [(*jin_.orderR_)[currR_]];
00820         break;
00821     case ibis::UINT:
00822         out << (*(static_cast<const array_t<uint32_t>*>(valR_[ind])))
00823             [(*jin_.orderR_)[currR_]];
00824         break;
00825     case ibis::LONG:
00826         out << (*(static_cast<const array_t<int64_t>*>(valR_[ind])))
00827             [(*jin_.orderR_)[currR_]];
00828         break;
00829     case ibis::ULONG:
00830         out << (*(static_cast<const array_t<uint64_t>*>(valR_[ind])))
00831             [(*jin_.orderR_)[currR_]];
00832         break;
00833     case ibis::FLOAT:
00834         out << (*(static_cast<const array_t<float>*>(valR_[ind])))
00835             [(*jin_.orderR_)[currR_]];
00836         break;
00837     case ibis::DOUBLE:
00838         out << (*(static_cast<const array_t<double>*>(valR_[ind])))
00839             [(*jin_.orderR_)[currR_]];
00840         break;
00841     case ibis::TEXT:
00842     case ibis::CATEGORY:
00843         out << (*(static_cast<const std::vector<std::string>*>(valR_[ind])))
00844             [(*jin_.orderR_)[currR_]];
00845         break;
00846     }
00847 } // ibis::joinIN::result::dumpR
00848 
00849 inline void
00850 ibis::joinIN::result::dumpS(std::ostream& out, uint32_t ind) const {
00851     if (colS_[ind] == 0) return;
00852     switch (typeS_[ind]) {
00853     default: break;
00854     case ibis::BYTE:
00855         out << (int)(*(static_cast<const array_t<char>*>(valS_[ind])))
00856             [(*jin_.orderS_)[currS_]];
00857         break;
00858     case ibis::UBYTE:
00859         out << (int)(*(static_cast<const array_t<unsigned char>*>(valS_[ind])))
00860             [(*jin_.orderS_)[currS_]];
00861         break;
00862     case ibis::SHORT:
00863         out << (*(static_cast<const array_t<int16_t>*>(valS_[ind])))
00864             [(*jin_.orderS_)[currS_]];
00865         break;
00866     case ibis::USHORT:
00867         out << (*(static_cast<const array_t<uint16_t>*>(valS_[ind])))
00868             [(*jin_.orderS_)[currS_]];
00869         break;
00870     case ibis::INT:
00871         out << (*(static_cast<const array_t<int32_t>*>(valS_[ind])))
00872             [(*jin_.orderS_)[currS_]];
00873         break;
00874     case ibis::UINT:
00875         out << (*(static_cast<const array_t<uint32_t>*>(valS_[ind])))
00876             [(*jin_.orderS_)[currS_]];
00877         break;
00878     case ibis::LONG:
00879         out << (*(static_cast<const array_t<int64_t>*>(valS_[ind])))
00880             [(*jin_.orderS_)[currS_]];
00881         break;
00882     case ibis::ULONG:
00883         out << (*(static_cast<const array_t<uint64_t>*>(valS_[ind])))
00884             [(*jin_.orderS_)[currS_]];
00885         break;
00886     case ibis::FLOAT:
00887         out << (*(static_cast<const array_t<float>*>(valS_[ind])))
00888             [(*jin_.orderS_)[currS_]];
00889         break;
00890     case ibis::DOUBLE:
00891         out << (*(static_cast<const array_t<double>*>(valS_[ind])))
00892             [(*jin_.orderS_)[currS_]];
00893         break;
00894     case ibis::TEXT:
00895     case ibis::CATEGORY:
00896         out << (*(static_cast<const std::vector<std::string>*>(valS_[ind])))
00897             [(*jin_.orderS_)[currS_]];
00898         break;
00899     }
00900 } // ibis::joinIN::result::dumpS
00901 #endif


	Contact us Disclaimers FastBit source code FastBit mailing list archive