00001
00002
00003
00004
00005 #ifndef IBIS_BORD_H
00006 #define IBIS_BORD_H
00007 #include "table.h"
00008 #include "util.h"
00009 #include "part.h"
00010 #include "selectClause.h"
00011
00015 namespace ibis {
00016 class bord;
00017 }
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
00171 class cursor;
00173 virtual ibis::table::cursor* createCursor() const;
00174
00175
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
00476 bord(const bord&);
00477 bord& operator=(const bord&);
00478
00479 friend class cursor;
00480 };
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&);
00588 };
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 };
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;
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 };
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 }
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 }
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 }
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 }
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 }
01198
01199 inline int ibis::bord::cursor::fetch() {
01200 ++ curRow;
01201 return (0 - (curRow >= (int64_t) tab.nRows()));
01202 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
01426 #endif // IBIS_BORD_H
