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
![]() |