00001
00002
00003
00004 #ifndef IBIS_JOININ_H
00005 #define IBIS_JOININ_H
00006
00012 #include "join.h"
00013
00014 namespace ibis {
00015 class joinIN;
00016 }
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&);
00052 joinIN& operator=(const joinIN&);
00053 };
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&);
00113 result& operator=(const result&);
00114 };
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
00901 #endif
