SWC-DB  v0.5.12 C++ documentations
SWC-DB© (Super Wide Column Database) - High Performance Scalable Database (https://github.com/kashirin-alex/swc-db)
Range.cc
Go to the documentation of this file.
1 /*
2  * SWC-DB© Copyright since 2019 Alex Kashirin <kashirin.alex@gmail.com>
3  * License details at <https://github.com/kashirin-alex/swc-db/#license>
4  */
5 
6 
9 
15 
16 
17 namespace SWC { namespace Ranger {
18 
19 
20 
22  public:
23  typedef std::shared_ptr<MetaRegOnLoadReq> Ptr;
24 
26  static Ptr make(const RangePtr& range,
28  return Ptr(new MetaRegOnLoadReq(range, req));
29  }
30 
32 
34  MetaRegOnLoadReq(const RangePtr& a_range,
35  const Callback::RangeLoad::Ptr& a_req)
36  : Query::Update::BaseMeta(a_range), req(a_req) {
37  }
38 
39  virtual ~MetaRegOnLoadReq() noexcept { }
40 
41  virtual void response(int err=Error::OK) override {
42  struct Task {
43  Ptr ptr;
45  Task(Ptr&& a_ptr) noexcept : ptr(std::move(a_ptr)) { }
47  Task(Task&& other) noexcept : ptr(std::move(other.ptr)) { }
48  Task(const Task&) = delete;
49  Task& operator=(Task&&) = delete;
50  Task& operator=(const Task&) = delete;
51  ~Task() noexcept { }
52  void operator()() { ptr->callback(); }
53  };
54  if(is_last_rsp(err)) {
55  Env::Rgr::post(Task(
56  std::dynamic_pointer_cast<MetaRegOnLoadReq>(shared_from_this())));
57  }
58  }
59 
60  virtual void callback() override {
61  range->loaded(error(), req);
62  }
63 
64 };
65 
66 
67 
68 const char* SWC_CONST_FUNC to_string(Range::State state) noexcept {
69  switch(state) {
70  case Range::State::NOTLOADED:
71  return "NOTLOADED";
73  return "LOADING";
74  case Range::State::LOADED:
75  return "LOADED";
76  case Range::State::UNLOADING:
77  return "UNLOADING";
79  return "DELETED";
80  default:
81  return "UNKNOWN";
82  }
83 }
84 
85 
89  TaskRunQueueScan(RangePtr&& a_ptr) noexcept : ptr(std::move(a_ptr)) { }
92  : ptr(std::move(other.ptr)) {
93  }
97  ~TaskRunQueueScan() noexcept { }
98  void operator()() { ptr->_run_scan_queue(); }
99 };
100 
104  TaskRunQueueAdd(const RangePtr& a_ptr) noexcept : ptr(a_ptr) { }
105  TaskRunQueueAdd(RangePtr&& a_ptr) noexcept : ptr(std::move(a_ptr)) { }
108  : ptr(std::move(other.ptr)) {
109  }
113  ~TaskRunQueueAdd() noexcept { }
114  void operator()() { ptr->_run_add_queue(); }
115 };
116 
117 
119 Range::Range(const ColumnCfg::Ptr& a_cfg, const rid_t a_rid)
120  : cfg(a_cfg), rid(a_rid),
121  blocks(cfg->key_seq),
122  prev_range_end(),
123  m_path(DB::RangeBase::get_path(cfg->cid, rid)),
124  m_mutex_intval(), m_mutex_intval_alignment(),
125  m_interval(cfg->key_seq), m_load_revision(0),
126  m_mutex(),
127  m_state(State::NOTLOADED),
128  m_compacting(COMPACT_NONE), m_require_compact(false),
129  m_q_run_add(false), m_q_run_scan(false),
130  m_adding(0),
131  m_q_add(), m_q_scan(), m_cv() { //, m_inbytes(0)
133 }
134 
136 void Range::init() {
137  blocks.init(shared_from_this());
138 }
139 
140 Range::~Range() noexcept {
142 }
143 
144 std::string Range::get_path(const std::string suff) const {
145  std::string s;
146  s.reserve(m_path.length() + suff.length());
147  s.append(m_path);
148  s.append(suff);
149  return s;
150 }
151 
153 std::string Range::get_path_cs(const csid_t csid) const {
155 }
156 
158 std::string Range::get_path_cs_on(const std::string folder,
159  const csid_t csid) const {
160  return DB::RangeBase::get_path_cs(m_path, folder, csid);
161 }
162 
163 void Range::set_rgr(int& err) const noexcept {
167  err, DB::RangeBase::get_path_ranger(m_path), cfg->file_replication()
168  )
169  : Env::Rgr::rgr_data()->set_rgr(err, cfg->cid, rid);
170 }
171 
172 void Range::remove_rgr(int& err) const noexcept {
174  ? Env::FsInterface::interface()->remove(
175  err, DB::RangeBase::get_path_ranger(m_path))
176  : DB::RgrData::remove(err, cfg->cid, rid);
177 }
178 
182  return m_interval.key_end.empty()
185 }
186 
191  _get_interval(interval);
192 }
193 
195  {
197  if(_is_any_begin())
198  return false;
199  }
200  if(!blocks.commitlog.empty())
201  return false;
203  return m_state == State::LOADED &&
205  !blocks.cellstores.size_bytes(false);
206 }
207 
210  interval.copy(m_interval);
211 }
212 
215  DB::Cell::Key& key_end) const {
216  key_begin.copy(m_interval.key_begin);
217  key_end.copy(m_interval.key_end);
218 }
219 
221 bool Range::_is_any_begin() const {
222  return m_interval.key_begin.empty();
223 }
224 
226 bool Range::_is_any_end() const {
227  return m_interval.key_end.empty();
228 }
229 
231 void Range::schema_update(bool compact) {
233  if(compact)
234  compact_require(true);
235 }
236 
239  m_state.store(new_state);
240 }
241 
245 }
246 
249  return m_load_revision.load();
250 }
251 
255  return m_state == State::LOADED;
256 }
257 
261  return m_state == State::DELETED;
262 }
263 
265 void Range::state(int& err) const {
266  if(m_state != State::LOADED) {
267  err = m_state == State::DELETED
270  }
271 }
272 
274 bool Range::state_unloading() const noexcept {
275  return Env::Rgr::is_shuttingdown() ||
278 }
279 
282  m_q_add.push(req);
283  run_add_queue();
284 }
285 
287  {
290  if(!m_q_scan.push_and_is_1st(std::move(req))) {
291  auto check(std::move(m_q_scan));
292  while(check.pop(&req)) {
293  if(!req->expired())
294  m_q_scan.push(std::move(req));
295  }
296  }
297  m_q_run_scan = true;
298  return;
299  }
301  }
302  blocks.scan(std::move(req));
304 }
305 
307  {
310  m_q_run_scan = true;
311  return;
312  }
314  }
315 
316  struct Task {
317  RangePtr ptr;
318  ReqScan::Ptr req;
320  Task(RangePtr&& a_ptr, ReqScan::Ptr&& a_req) noexcept
321  : ptr(std::move(a_ptr)), req(std::move(a_req)) {
322  ptr->blocks.processing_increment();
323  }
325  Task(Task&& other) noexcept
326  : ptr(std::move(other.ptr)), req(std::move(other.req)) {
327  }
328  Task(const Task&) = delete;
329  Task& operator=(Task&&) = delete;
330  Task& operator=(const Task&) = delete;
331  ~Task() noexcept { }
332  void operator()() {
333  ptr->blocks.scan(std::move(req));
334  ptr->blocks.processing_decrement();
335  }
336  };
337 
338  for(ReqScan::Ptr req; m_q_scan.pop(&req); ) {
339  if(!req->expired()) {
340  int err = Error::OK;
341  state(err);
342  if(err) {
343  req->response(err);
344  } else {
345  Env::Rgr::post(Task(shared_from_this(), std::move(req)));
346  }
347  }
348  }
350 }
351 
354  blocks.scan(std::move(req));
355 }
356 
359 
360  bool need;
361  {
362  auto at(State::NOTLOADED);
365  }
366 
368  if(need && !err) {
370  "LOADING RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ")-STARTED",
371  cfg->cid, rid);
372 
374  err, get_path(DB::RangeBase::CELLSTORES_DIR)) && !err &&
376  err, get_path(Range::CELLSTORES_BAK_DIR)) && !err) {
378  if(!err)
379  return internal_take_ownership(err, req);
380  } else if(!err) {
381  return last_rgr_chk(err, req);
382  }
383  }
384  return loaded(err, req);
385 }
386 
388  const Callback::RangeLoad::Ptr& req) {
390  "LOADING RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ")-TAKE OWNERSHIP",
391  cfg->cid, rid);
392 
393  if(state_unloading())
394  return loaded(Error::SERVER_SHUTTING_DOWN, req);
395 
399  err, DB::RangeBase::get_path_ranger(m_path), cfg->file_replication()
400  );
401  err ? loaded(err, req) : load(err, req);
402  return;
403  }
404 
405  class SetRgr : public DB::RgrData::BaseUpdater {
406  public:
407  typedef std::shared_ptr<SetRgr> Ptr;
408  RangePtr range;
410  SetRgr(RangePtr&& a_range,
411  const Callback::RangeLoad::Ptr& a_req) noexcept
412  : range(std::move(a_range)), req(a_req) { }
413  virtual ~SetRgr() noexcept { }
414  void callback() override {
415  struct Task {
416  SetRgr::Ptr ptr;
418  Task(SetRgr::Ptr&& a_ptr) noexcept : ptr(std::move(a_ptr)) { }
420  Task(Task&& other) noexcept : ptr(std::move(other.ptr)) { }
421  Task(const Task&) = delete;
422  Task& operator=(Task&&) = delete;
423  Task& operator=(const Task&) = delete;
424  ~Task() noexcept { }
425  void operator()() {
426  int err = ptr->error();
427  err
428  ? ptr->range->loaded(err, ptr->req)
429  : ptr->range->load(err, ptr->req);
430  }
431  };
432  Env::Rgr::post(Task(
433  std::dynamic_pointer_cast<SetRgr>(shared_from_this())));
434  }
435  };
436  SetRgr::Ptr(new SetRgr(shared_from_this(), req))
437  ->set_rgr(*Env::Rgr::rgr_data(), cfg->cid, rid);
438 }
439 
440 void Range::internal_unload(bool completely, bool& chk_empty) {
441  {
443  if(m_state != State::LOADED && !blocks.range)
444  return;
445  m_state.store(State::UNLOADING);
446  }
448  "UNLOADING RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ")",
449  cfg->cid, rid);
450 
452 
453  wait();
454  wait_queue();
455 
456  if(chk_empty)
457  chk_empty = !blocks.size_bytes_total(false);
458  blocks.unload();
459 
460  int err = Error::OK;
461  if(completely) // whether to keep RANGER_FILE
462  remove_rgr(err);
463 
464  {
466  m_state.store(State::NOTLOADED);
467  }
469  "UNLOADED RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ") error=%d(%s)",
470  cfg->cid, rid, err, Error::get_text(err));
471 }
472 
474  auto col = Env::Rgr::columns()->get_column(cfg->cid);
475  if(col && !col->removing())
476  col->add_managing(Callback::RangeUnloadInternal::Ptr(
478 }
479 
481  {
484  return req->removed(shared_from_this());
485  }
487  "REMOVING RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ")",
488  cfg->cid, rid);
489 
491 
492  on_change(
493  true,
495  shared_from_this(),
496  [req] (const Query::Update::CommonMeta::Ptr& hdlr) {
497  int err = Error::OK;
498 
499  hdlr->range->wait();
500  hdlr->range->wait_queue();
501  hdlr->range->blocks.remove(err);
502 
503  Env::FsInterface::interface()->rmdir(err, hdlr->range->get_path(""));
504  /* Manager clears all column ranges
505  if(!DB::Types::SystemColumn::is_rgr_data_on_fs(hdlr->range->cfg->cid))
506  DB::RgrData::remove(err, hdlr->range->cfg->cid, hdlr->range->rid);
507  */
508  req->removed(hdlr->range);
509  }
510  )
511  );
512 }
513 
514 void Range::internal_remove(int& err) {
515  {
518  return;
519  }
521  "REMOVING RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ")",
522  cfg->cid, rid);
523 
525 
526  wait();
527  wait_queue();
528  blocks.remove(err);
529 
530  Env::FsInterface::interface()->rmdir(err, get_path(""));
531 
532  SWC_LOG_OUT(LOG_INFO, print(SWC_LOG_OSTREAM << "REMOVED RANGE "); );
533 }
534 
536  while(m_adding || !m_q_add.empty() || !m_q_scan.empty())
537  std::this_thread::sleep_for(std::chrono::milliseconds(1));
538 }
539 
543  return m_compacting != COMPACT_NONE;
544 }
545 
549  return m_compacting == COMPACT_APPLYING;
550 }
551 
552 void Range::compacting(uint8_t state) {
553  bool do_q_run_add;
554  bool do_q_run_scan;
555  {
558  m_cv.notify_all();
560  return;
561 
562  if((do_q_run_add = m_q_run_add && state < COMPACT_PREPARING))
563  m_q_run_add = false;
564  if((do_q_run_scan = m_q_run_scan))
565  m_q_run_scan = false;
566  }
567  if(do_q_run_add)
568  run_add_queue();
569  if(do_q_run_scan)
570  Env::Rgr::post(TaskRunQueueScan(shared_from_this()));
571 }
572 
573 bool Range::compacting_ifnot_applying(uint8_t state) {
574  bool do_q_run_add;
575  bool do_q_run_scan;
576  {
579  return false;
581  m_cv.notify_all();
582 
583  if((do_q_run_add = m_q_run_add && state < COMPACT_PREPARING))
584  m_q_run_add = false;
585  if((do_q_run_scan = m_q_run_scan))
586  m_q_run_scan = false;
587  }
588  if(do_q_run_add)
589  run_add_queue();
590  if(do_q_run_scan)
591  Env::Rgr::post(TaskRunQueueScan(shared_from_this()));
592  return true;
593 }
594 
595 bool Range::compact_possible(bool minor) {
597  if(m_state != State::LOADED || m_compacting != COMPACT_NONE ||
598  (!minor && !m_require_compact && blocks.processing()))
599  return false;
601  return true;
602 }
603 
605 void Range::compact_require(bool require) {
606  m_require_compact.store(require);
607 }
608 
611  return m_require_compact;
612 }
613 
614 void Range::on_change(bool removal,
615  const Query::Update::BaseMeta::Ptr& hdlr,
616  const DB::Cell::Key* old_key_begin) {
617  if(cfg->range_type == DB::Types::Range::MASTER) {
618  // update manager-root
619  // Mngr::RangeUpdated
620  hdlr->callback();
621  return;
622  }
623 
624  DB::Cells::Cell cell;
625  auto cid_f(std::to_string(cfg->cid));
626 
627  if(removal) {
628  cell.flag = DB::Cells::DELETE_LE;
630  cell.key.insert(0, cid_f);
631  hdlr->column.add(cell);
632 
633  } else {
634  cell.flag = DB::Cells::INSERT;
635 
637  cell.key.insert(0, cid_f);
638 
640  key_end.insert(0, cid_f);
641 
642  DB::Cell::Key aligned_min;
643  DB::Cell::Key aligned_max;
644  if(cfg->range_type == DB::Types::Range::DATA) {
645  aligned_min.add(cid_f);
646  aligned_max.add(cid_f);
647  // only DATA until MASTER/META aligned on cells value min/max
649  aligned_min.add(m_interval.aligned_min);
650  aligned_max.add(m_interval.aligned_max);
651  }
652 
654  wfields.ensure(
655  key_end.encoded_length()
657  + aligned_min.encoded_length()
658  + aligned_max.encoded_length()
659  + 8);
660  uint24_t fid = 0;
661  wfields.add(fid, key_end);
662  wfields.add(fid, int64_t(rid));
663  wfields.add(++fid, aligned_min);
664  wfields.add(++fid, aligned_max);
665  cell.set_value(wfields.base, wfields.fill(), false);
666 
667  cell.set_time_order_desc(true);
668  hdlr->column.add(cell);
669 
670  if(old_key_begin && !old_key_begin->equal(m_interval.key_begin)) {
671  SWC_ASSERT(!old_key_begin->empty());
672  // remove begin-any should not happen
673 
674  cell.free();
675  cell.flag = DB::Cells::DELETE_LE;
676  cell.key.copy(*old_key_begin);
677  cell.key.insert(0, std::to_string(cfg->cid));
678  hdlr->column.add(cell);
679  }
680  }
681 
682  hdlr->commit(&hdlr->column);
683  /* INSERT master-range(
684  col-{1,4}), key[cid+m_interval(data(cid)+key)], value[end, rid, min, max]
685  INSERT meta-range(
686  col-{5,8}), key[cid+m_interval(key)], value[end, rid, min, max]
687  */
688 }
689 
690 void Range::apply_new(int &err,
691  CellStore::Writers& w_cellstores,
692  CommitLog::Fragments::Vec& fragments_old,
693  const Query::Update::BaseMeta::Ptr& hdlr) {
694  {
696  blocks.apply_new(err, w_cellstores, fragments_old);
697  if(err)
698  return;
699  }
700  if(hdlr)
701  expand_and_align(true, hdlr);
702 }
703 
704 void Range::expand_and_align(bool w_chg_chk,
705  const Query::Update::BaseMeta::Ptr& hdlr) {
706  DB::Cell::Key old_key_begin;
707  DB::Cell::Key key_end;
708  DB::Cell::KeyVec aligned_min;
709  DB::Cell::KeyVec aligned_max;
710 
711  if(w_chg_chk) {
712  old_key_begin.copy(m_interval.key_begin);
713  key_end.copy(m_interval.key_end);
714  aligned_min.copy(m_interval.aligned_min);
715  aligned_max.copy(m_interval.aligned_max);
716  }
717 
718  {
721  m_interval.free();
722  if(cfg->range_type == DB::Types::Range::DATA)
724  else
726  }
727 
728  if(!w_chg_chk ||
729  !m_interval.key_begin.equal(old_key_begin) ||
730  !m_interval.key_end.equal(key_end) ||
731  !m_interval.aligned_min.equal(aligned_min) ||
732  !m_interval.aligned_max.equal(aligned_max)) {
733  on_change(false, hdlr, w_chg_chk ? &old_key_begin : nullptr);
735  } else {
736  hdlr->callback();
737  }
738 }
739 
742  Env::FsInterface::interface()->mkdirs(
744  Env::FsInterface::interface()->mkdirs(
745  err, get_path(LOG_TMP_DIR));
746  Env::FsInterface::interface()->mkdirs(
748 }
749 
750 void Range::internal_create(int &err, const CellStore::Writers& w_cellstores) {
751  set_rgr(err);
752  if(err)
753  return;
754 
755  const auto& fs_if = Env::FsInterface::interface();
756  blocks.cellstores.reserve(w_cellstores.size());
757  for(auto& cs : w_cellstores) {
758  fs_if->rename(
759  err,
760  cs->smartfd->filepath(),
761  get_path_cs(cs->csid)
762  );
763  if(err)
764  return;
765 
767  CellStore::Read::make(err, cs->csid, shared_from_this(), true)
768  );
769  if(err)
770  return;
771  }
772 
773  #ifdef SWC_RANGER_WITH_RANGEDATA
775  #endif
776  remove_rgr(err);
777  err = Error::OK;
778 }
779 
781  set_rgr(err);
782  if(err)
783  return;
784 
785  blocks.cellstores.move_from(err, mv_css);
786  if(mv_css.empty())
787  err = Error::CANCELLED;
788  if(!err) {
789  #ifdef SWC_RANGER_WITH_RANGEDATA
791  #endif
792  remove_rgr(err);
793  err = Error::OK;
794  }
795 }
796 
797 void Range::print(std::ostream& out, bool minimal) {
798  cfg->print(out << '(');
799  out << " rid=" << rid << " state=" << to_string(m_state);
800  blocks.print(out << ' ', minimal);
801  prev_range_end.print(out << " prev=");
802  {
805  m_interval.print(out << ' ');
806  out << " revision=" << m_load_revision;
807  }
808  out << ')';
809 }
810 
811 void Range::last_rgr_chk(int &err, const Callback::RangeLoad::Ptr& req) {
813  "LOADING RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ")-CHECK LAST RGR",
814  cfg->cid, rid);
815 
817  DB::RgrData rgr_last;
820  if(!rgr_last.endpoints.empty()) {
822  Env::Rgr::rgr_data()->endpoints, rgr_last.endpoints)) {
823  return load(err, req);
824  }
825  if(!Comm::has_endpoint(
826  Env::Rgr::rgr_data()->endpoints, rgr_last.endpoints)) {
828  rgr_last.print(SWC_LOG_OSTREAM << "RANGER LAST=");
830  );
831  Env::Clients::get()->get_rgr_queue(rgr_last.endpoints)->put(
833  new Comm::Protocol::Rgr::Req::RangeUnload(shared_from_this(), req)
834  )
835  );
836  return;
837  }
838  }
839  return internal_take_ownership(err, req);
840  }
841 
842  class GetRgr : public DB::RgrData::BaseSelector {
843  public:
844  typedef std::shared_ptr<GetRgr> Ptr;
845  RangePtr range;
848  GetRgr(RangePtr&& a_range, const Callback::RangeLoad::Ptr& a_req)
849  noexcept : range(std::move(a_range)), req(a_req) { }
850  virtual ~GetRgr() noexcept { }
851  void callback() override {
852  struct Task {
853  GetRgr::Ptr ptr;
855  Task(GetRgr::Ptr&& a_ptr) noexcept : ptr(std::move(a_ptr)) { }
857  Task(Task&& other) noexcept : ptr(std::move(other.ptr)) { }
858  Task(const Task&) = delete;
859  Task& operator=(Task&&) = delete;
860  Task& operator=(const Task&) = delete;
861  ~Task() noexcept { }
862  void operator()() {
863  int err = Error::OK;
864  DB::RgrData rgr_last;
865  ptr->get_rgr(err, rgr_last);
866  if(err && err != ENOKEY)
867  return ptr->range->loaded(err, ptr->req);
868  if(!rgr_last.endpoints.empty()) {
870  Env::Rgr::rgr_data()->endpoints, rgr_last.endpoints)) {
871  return ptr->range->load(err, ptr->req);
872  }
873  if(!Comm::has_endpoint(
874  Env::Rgr::rgr_data()->endpoints, rgr_last.endpoints)) {
876  rgr_last.print(SWC_LOG_OSTREAM << "RANGER LAST=");
878  );
879  Env::Clients::get()->get_rgr_queue(rgr_last.endpoints)->put(
882  ptr->range, ptr->req)));
883  return;
884  }
885  }
886  return ptr->range->internal_take_ownership(err, ptr->req);
887  }
888  };
889  Env::Rgr::post(Task(
890  std::dynamic_pointer_cast<GetRgr>(shared_from_this())));
891  }
892  };
893  GetRgr::Ptr(new GetRgr(shared_from_this(), req))->scan(cfg->cid, rid);
894 }
895 
896 void Range::load(int &err, const Callback::RangeLoad::Ptr& req) {
898  "LOADING RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ")-DATA",
899  cfg->cid, rid);
900 
901  if(state_unloading())
902  return loaded(Error::SERVER_SHUTTING_DOWN, req);
903 
904  bool is_initial_column_range = false;
905  #ifdef SWC_RANGER_WITH_RANGEDATA
907  #else
909  #endif
910  if(err) {
911  (void)err;
912  //err = Error::OK; // ranger-to determine range-removal (+ Notify Mngr)
913 
914  } else if(blocks.cellstores.empty()) {
915  // init 1st cs(for log_cells)
916  auto cs = CellStore::create_initial(err, shared_from_this());
917  if(!err) {
918  blocks.cellstores.add(cs);
919  is_initial_column_range = true;
920  }
921  }
922 
923  if(!err)
924  blocks.load(err);
925 
926  if(err)
927  return loaded(err, req);
928 
930  {
933  m_interval.free();
934  if(cfg->range_type == DB::Types::Range::DATA)
936  else
938  }
939 
940  if(is_initial_column_range) {
941  #ifdef SWC_RANGER_WITH_RANGEDATA
943  #endif
944  return on_change(false, MetaRegOnLoadReq::make(shared_from_this(), req));
945  }
946 
947  if(cfg->range_type == DB::Types::Range::MASTER)
948  return loaded(err, req);
949 
951  "LOADING RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ")-CHECK META",
952  cfg->cid, rid);
953  Query::Select::CheckMeta::run(shared_from_this(), req);
954 }
955 
957  int err = hdlr->state_error;
959  "LOADING RANGE(" SWC_FMT_LU "/" SWC_FMT_LU ")-CHECK META err=%d(%s)",
960  cfg->cid, rid, err, Error::get_text(err));
961  if(err)
962  return loaded(err, hdlr->req);
963  if(state_unloading())
964  return loaded(Error::SERVER_SHUTTING_DOWN, hdlr->req);
965 
966  if(hdlr->empty()) {
969  << "Range MetaData missing cid=" << cfg->cid << " rid=" << rid;
971  SWC_LOG_OSTREAM << "\n\tauto-registering=");
972  hdlr->spec.print(
973  SWC_LOG_OSTREAM << "\n\tmeta-cid(" << hdlr->cid << ")=");
974  );
975  return on_change(
976  false, MetaRegOnLoadReq::make(shared_from_this(), hdlr->req));
977  }
978 
979  DB::Cells::Result cells;
980  hdlr->get_cells(cells);
981 
982  rid_t _rid = 0;
983  bool synced = cells.size() == 1;
984  if(!synced) {
987  << "Range MetaData DUPLICATE-RID cid=" << cfg->cid << " rid=" << rid;
988  m_interval.print(SWC_LOG_OSTREAM << "\n\tauto-del-registering=");
989  hdlr->spec.print(
990  SWC_LOG_OSTREAM << "\n\tmeta-cid(" << hdlr->cid << ")=");
991  cells.print(SWC_LOG_OSTREAM << "\n\t", DB::Types::Column::SERIAL, true);
992  );
993  } else { try {
994 
995  auto& cell = *cells[0];
996 
997  DB::Cells::Interval interval(cfg->key_seq);
998  interval.was_set = true;
999  /* Range MetaData does not include timestamp
1000  for the comparison use current interval ts */
1002  interval.ts_latest.copy(m_interval.ts_latest);
1003 
1004  interval.key_begin.copy(cell.key);
1005  interval.key_begin.remove(0);
1006 
1007  StaticBuffer v;
1008  cell.get_value(v, false);
1009  const uint8_t* ptr = v.base;
1010  size_t remain = v.size;
1011 
1013  interval.key_end.decode(&ptr, &remain, false);
1014  interval.key_end.remove(0);
1015 
1017  _rid = Serialization::decode_vi64(&ptr, &remain);
1018 
1020  interval.aligned_min.decode(&ptr, &remain);
1021  interval.aligned_min.remove(0);
1022 
1024  interval.aligned_max.decode(&ptr, &remain);
1025  interval.aligned_max.remove(0);
1026 
1027  synced = !remain && rid == _rid && m_interval.equal(interval);
1028  if(!synced) {
1030  SWC_LOG_OSTREAM << "Range MetaData NOT-SYNCED cid=" << cfg->cid;
1031  SWC_LOG_OSTREAM << "\n\t loaded-rid=" << rid;
1033  SWC_LOG_OSTREAM << "\n\tregistered-rid=" << _rid;
1034  interval.print(SWC_LOG_OSTREAM << ' ');
1035  );
1036  }
1037  } catch(...) {
1039  synced = false;
1040  } }
1041 
1042  if(synced)
1043  return loaded(err, hdlr->req);
1044 
1045  auto updater = MetaRegOnLoadReq::make(shared_from_this(), hdlr->req);
1046  for(auto cell : cells) {
1047  cell->flag = DB::Cells::DELETE_LE;
1048  cell->free();
1049  updater->column.add(*cell);
1050  }
1051  on_change(false, updater);
1052 }
1053 
1054 void Range::loaded(int err, const Callback::RangeLoad::Ptr& req) {
1055  if(!err && state_unloading())
1057  bool tried;
1058  {
1059  Core::ScopedLock lock(m_mutex);
1060  tried = m_state == State::LOADING;
1061  if(tried)
1062  m_state.store(err ? State::NOTLOADED : State::LOADED);
1063  }
1064  if(tried && !err)
1066 
1068  if(!tried)
1069  SWC_LOG_OSTREAM << "CHECK ";
1070  SWC_LOG_OSTREAM << "LOAD RANGE ";
1071  if(_log_pr == LOG_INFO)
1072  SWC_LOG_OSTREAM << "SUCCEED";
1073  else
1074  Error::print(SWC_LOG_OSTREAM << "FAILED ", err);
1075  print(SWC_LOG_OSTREAM << ' ', _log_pr == LOG_INFO &&
1076  err != Error::SERVER_SHUTTING_DOWN &&
1078  );
1079 
1081  req->loaded(err);
1082 }
1083 
1084 bool Range::wait(uint8_t from_state, bool incr) {
1085  bool waited;
1086  Core::UniqueLock lock_wait(m_mutex);
1087  if((waited = (m_compacting >= from_state))) {
1088  m_cv.wait(
1089  lock_wait,
1090  [this, from_state]() {
1091  return m_compacting < from_state;
1092  }
1093  );
1094  }
1095  if(incr)
1097  return waited;
1098 }
1099 
1102  Env::Rgr::post(TaskRunQueueAdd(shared_from_this()));
1103  else
1104  m_adding.fetch_sub(1);
1105 }
1106 
1107 
1108 
1110  public:
1111  typedef std::shared_ptr<MetaRegOnAddReq> Ptr;
1112 
1115  return Ptr(new MetaRegOnAddReq(range, req));
1116  }
1117 
1119 
1122  : Query::Update::BaseMeta(a_range), req(a_req) {
1123  }
1124 
1129 
1130  virtual ~MetaRegOnAddReq() noexcept { }
1131 
1132  virtual void response(int err=Error::OK) override {
1133  if(is_last_rsp(err))
1134  callback();
1135  }
1136 
1137  virtual void callback() override {
1140  req->rsp.err = error();
1141 
1142  req->response();
1143  bool added = req->rsp.cells_added;
1144  delete req;
1145  if(added)
1146  range->blocks.commitlog.commit();
1147  range->blocks.processing_decrement();
1148  }
1149 
1150 };
1151 
1152 
1154  const uint64_t ttl = cfg->cell_ttl();
1155 
1156  DB::Cell::KeyVec align_min;
1157  DB::Cell::KeyVec align_max;
1158 
1159  while(!m_q_add.empty()) {
1160  {
1161  Core::ScopedLock lock(m_mutex);
1163  auto check(std::move(m_q_add));
1164  for(Callback::RangeQueryUpdate* req; (req = check.next()); ) {
1165  if(req->expired()) {
1166  delete req;
1167  } else {
1168  req->_other = nullptr;
1169  m_q_add.push(req);
1170  }
1171  }
1172  m_q_run_add = true;
1173  m_adding.fetch_sub(1);
1174  return;
1175  }
1177  // Compaction won't change m_interval while processing positive
1178  // _run_add_queue is not running at COMPACT_PREPARING+
1179  }
1180 
1181  Callback::RangeQueryUpdate* req = m_q_add.next();
1182  if(!req) {
1184  break;
1185  }
1186 
1187  if(req->expired()) {
1189  goto _response;
1190  }
1191 
1192  if(m_state != State::LOADED && m_state != State::UNLOADING) {
1193  req->rsp.err = m_state == State::DELETED
1195  goto _response;
1196  }
1197 
1198  {
1199  const uint8_t* buf = req->ev->data_ext.base;
1200  size_t remain = req->ev->data_ext.size;
1201  bool aligned_chg = false;
1202 
1203  try { for(DB::Cells::Cell cell; remain; ) {
1204 
1205  cell.read(&buf, &remain, false);
1206 
1207  if(!m_interval.key_end.empty() &&
1208  DB::KeySeq::compare(cfg->key_seq, m_interval.key_end, cell.key)
1209  == Condition::GT) {
1210  if(req->rsp.range_end.empty()) {
1213  }
1214  continue;
1215  }
1216 
1217  if(!prev_range_end.empty() &&
1218  DB::KeySeq::compare(cfg->key_seq, prev_range_end, cell.key)
1219  != Condition::GT) {
1220  if(req->rsp.range_prev_end.empty()) {
1223  }
1224  continue;
1225  }
1226 
1227  ++req->rsp.cells_added;
1228  if(cell.has_expired(ttl))
1229  continue;
1230 
1231  auto ts = Time::now_ns();
1232  cell.control & DB::Cells::HAVE_TIMESTAMP
1233  ? cell.set_revision(ts)
1234  : cell.set_timestamp_with_rev_is_ts(ts);
1235 
1236  blocks.add_logged(cell);
1237 
1238  switch(cfg->range_type) {
1239  case DB::Types::Range::DATA: {
1240  if(DB::KeySeq::align(cfg->key_seq, cell.key, align_min, align_max))
1241  aligned_chg = true;
1242  break;
1243  }
1244  default: {
1245  /* MASTER/META need aligned interval
1246  over cells value +plus (cs+logs) at compact
1247  if(cell.flag == DB::Cells::INSERT) {
1248  size_t remain = cell.vlen;
1249  const uint8_t * ptr = cell.value;
1250  DB::Cell::Key key_end;
1251  key_end.decode(&ptr, &remain);
1252  Serialization::decode_vi64(&ptr, &remain);//rid
1253  DB::Cell::Key aligned_min;
1254  aligned_min.decode(&ptr, &remain);
1255  DB::Cell::Key aligned_max;
1256  aligned_max.decode(&ptr, &remain);
1257  aligned_chg = align(aligned_min);
1258  if(align(aligned_max))
1259  aligned_chg = true;
1260  }
1261  */
1262  break;
1263  }
1264  }
1265  } } catch(...) {
1268  }
1269 
1270  if(aligned_chg) {
1272  aligned_chg = m_interval.align(align_min, align_max);
1273  }
1274  if(aligned_chg)
1275  return on_change(false, MetaRegOnAddReq::make(shared_from_this(), req));
1276 
1277  }
1278 
1279  _response:
1280  req->response();
1281  bool added = req->rsp.cells_added;
1282  delete req;
1283  if(added)
1286  }
1287 
1288  if(m_adding.fetch_sub(1) == 1 && !m_q_add.empty())
1289  run_add_queue();
1290 }
1291 
1292 
1293 }}
1294 
1295 
SWC::Ranger::Range::compacting
bool compacting()
Definition: Range.cc:541
SWC::Ranger::Range::apply_new
void apply_new(int &err, CellStore::Writers &w_cellstores, CommitLog::Fragments::Vec &fragments_old, const Query::Update::BaseMeta::Ptr &hdlr=nullptr)
Definition: Range.cc:690
SWC::Ranger::Range::TaskRunQueueAdd::ptr
RangePtr ptr
Definition: Range.cc:102
SWC::Ranger::Range::get_path_cs_on
std::string get_path_cs_on(const std::string folder, const csid_t csid) const
Definition: Range.cc:158
SWC::Ranger::RangeData::save
void save(int &err, CellStore::Readers &cellstores)
Definition: RangeData.cc:40
SWC::Ranger::Range::MetaRegOnLoadReq::req
Callback::RangeLoad::Ptr req
Definition: Range.cc:31
SWC::Core::AtomicBase::compare_exchange_weak
constexpr SWC_CAN_INLINE bool compare_exchange_weak(T &at, T value) noexcept
Definition: Atomic.h:52
SWC::Config::Property::Value_uint8_g::get
SWC_CAN_INLINE uint8_t get() const noexcept
Definition: Property.h:535
SWC::DB::RangeBase::get_path_cs
static const std::string get_path_cs(const std::string &range_path, const std::string &folder, const csid_t csid)
Definition: RangeBase.h:81
SWC::Error::RGR_NOT_LOADED_RANGE
@ RGR_NOT_LOADED_RANGE
Definition: Error.h:91
SWC::Core::QueueSafe::push_and_is_1st
SWC_CAN_INLINE bool push_and_is_1st(const ItemT &item)
Definition: QueueSafe.h:54
SWC::Ranger::CommitLog::Fragments::empty
bool empty()
Definition: CommitLog.cc:514
SWC::Ranger::Range::add
void add(Callback::RangeQueryUpdate *req)
Definition: Range.cc:281
SWC::DB::Cells::Interval::key_end
DB::Cell::Key key_end
Definition: Interval.h:225
SWC::DB::Cells::Cell::set_value
SWC_CAN_INLINE void set_value(uint8_t *v, uint32_t len, bool owner)
Definition: Cell.h:223
SWC::Ranger::Range::loaded
void loaded(int err, const Callback::RangeLoad::Ptr &req)
Definition: Range.cc:1054
SWC::Ranger::Range::_run_scan_queue
void _run_scan_queue()
Definition: Range.cc:306
SWC_LOG_OSTREAM
#define SWC_LOG_OSTREAM
Definition: Logger.h:44
BaseMeta.cc
SWC::Error::REQUEST_TIMEOUT
@ REQUEST_TIMEOUT
Definition: Error.h:73
SWC::Ranger::Range::Range
Range(const ColumnCfg::Ptr &cfg, const rid_t rid)
Definition: Range.cc:119
SWC::DB::KeySeq::align
bool align(const Types::KeySeq seq, const Cell::Key &key, Cell::KeyVec &start, Cell::KeyVec &finish) SWC_ATTRIBS((SWC_ATTRIB_O3))
Definition: KeyComparator.h:668
SWC::Ranger::Range::TaskRunQueueScan::ptr
RangePtr ptr
Definition: Range.cc:87
SWC::Ranger::Range::TaskRunQueueAdd
Definition: Range.cc:101
SWC::Error::SERVER_SHUTTING_DOWN
@ SERVER_SHUTTING_DOWN
Definition: Error.h:84
SWC::Env::Clients::get
static SWC_CAN_INLINE client::Clients::Ptr & get() noexcept
Definition: Clients.h:299
SWC_LOGF
#define SWC_LOGF(priority, fmt,...)
Definition: Logger.h:188
SWC::Ranger::Range::internal_take_ownership
void internal_take_ownership(int &err, const Callback::RangeLoad::Ptr &req)
Definition: Range.cc:387
SWC::Ranger::Range::~Range
~Range() noexcept
Definition: Range.cc:140
SWC::Ranger::Range::LOG_TMP_DIR
static constexpr const char LOG_TMP_DIR[]
Definition: Range.h:40
SWC::Core::UniqueLock
Definition: MutexLock.h:68
SWC_LOG_OUT
#define SWC_LOG_OUT(pr, _code_)
Definition: Logger.h:178
SWC::Time::now_ns
SWC_CAN_INLINE int64_t now_ns() noexcept
Definition: Time.h:43
CommonMeta.h
SWC::Ranger::Range::m_q_scan
Core::QueueSafe< ReqScan::Ptr > m_q_scan
Definition: Range.h:198
SWC::Ranger::Range::TaskRunQueueScan::operator=
TaskRunQueueScan & operator=(const TaskRunQueueScan &)=delete
RangeUnload.h
SWC::Ranger::Range::MetaRegOnLoadReq::Ptr
std::shared_ptr< MetaRegOnLoadReq > Ptr
Definition: Range.cc:23
SWC::DB::Cell::KeyVec
Definition: CellKeyVec.h:21
SWC::Comm::Protocol::FsBroker::Handler::exists
void exists(const ConnHandlerPtr &conn, const Event::Ptr &ev)
Definition: Exists.h:17
SWC::Ranger::Range::get_path
std::string get_path(const std::string suff) const
Definition: Range.cc:144
SWC::Core::ScopedLock
Definition: MutexLock.h:41
SWC::Env::Rgr::rgr_data
static SWC_CAN_INLINE DB::RgrData * rgr_data() noexcept
Definition: RangerEnv.h:48
SWC::Ranger::Range::expand_and_align
void expand_and_align(bool w_chg_chk, const Query::Update::BaseMeta::Ptr &hdlr)
Definition: Range.cc:704
SpecsValueSerialFields.h
SWC::Env::Rgr::in_process_ranges
static SWC_CAN_INLINE int64_t in_process_ranges() noexcept
Definition: RangerEnv.h:73
SWC::Error::get_text
const char * get_text(const int err) noexcept
Definition: Error.cc:173
SWC::DB::Cell::KeyVec::remove
void remove(const uint32_t idx)
Definition: CellKeyVec.h:209
SWC::DB::Cells::Interval::align
SWC_CAN_INLINE bool align(const Interval &other)
Definition: Interval.h:152
SWC::Ranger::Range::deleted
bool deleted()
Definition: Range.cc:259
SWC::DB::Cells::Cell::free
SWC_CAN_INLINE void free() noexcept
Definition: Cell.h:162
SWC::Ranger::Range::TaskRunQueueScan::TaskRunQueueScan
TaskRunQueueScan(const TaskRunQueueScan &)=delete
SWC::DB::Types::SystemColumn::is_data
constexpr SWC_CAN_INLINE bool is_data(cid_t cid) noexcept
Definition: SystemColumn.h:46
SWC::Condition::GT
@ GT
Definition: Comparators.h:30
SWC::Ranger::Range::issue_unload
void issue_unload()
Definition: Range.cc:473
SWC::Ranger::Blocks::expand_and_align
void expand_and_align(DB::Cells::Interval &intval)
Definition: RangeBlocks.cc:89
SWC::Ranger::Blocks::remove
void remove(int &err)
Definition: RangeBlocks.cc:68
SWC::Env::Rgr::columns
static SWC_CAN_INLINE Ranger::Columns * columns() noexcept
Definition: RangerEnv.h:144
SWC::client::Query::Update::Handlers::Base::Ptr
std::shared_ptr< Base > Ptr
Definition: Base.h:27
SWC::Env::FsInterface::interface
static SWC_CAN_INLINE FS::Interface::Ptr & interface() noexcept
Definition: Interface.h:150
SWC::DB::Cells::Interval::aligned_max
DB::Cell::KeyVec aligned_max
Definition: Interval.h:229
SWC::DB::Cells::Interval::print
void print(std::ostream &out) const
Definition: Interval.cc:146
SWC::Core::SharedLock
Definition: MutexLock.h:19
SWC::LOG_INFO
@ LOG_INFO
Definition: Logger.h:35
SWC::DB::Specs::Timestamp::copy
constexpr SWC_CAN_INLINE void copy(const Timestamp &other) noexcept
Definition: SpecsTimestamp.h:49
SWC::DB::Cell::Key::insert
SWC_CAN_INLINE void insert(uint32_t idx, const std::string &fraction)
Definition: CellKey.h:150
SWC::Ranger::Range::COMPACT_CHECKING
static const uint8_t COMPACT_CHECKING
Definition: Range.h:52
SWC::Ranger::Range::remove_rgr
void remove_rgr(int &err) const noexcept
Definition: Range.cc:172
SWC::Ranger::Range::check_meta
void check_meta(const Query::Select::CheckMeta::Ptr &hdlr)
Definition: Range.cc:956
SWC::Ranger::Range::load
void load(const Callback::RangeLoad::Ptr &req)
Definition: Range.cc:357
SWC::Ranger::Range::MetaRegOnLoadReq::callback
virtual void callback() override
Definition: Range.cc:60
SWC::Env::Rgr::cfg_req_add_concurrency
const SWC::Config::Property::Value_uint8_g::Ptr cfg_req_add_concurrency
Definition: RangerEnv.h:162
SWC::csid_t
uint32_t csid_t
Definition: Identifiers.h:19
SWC::Core::BufferDyn::ensure
SWC_CAN_INLINE void ensure(size_t len)
Definition: Buffer.h:212
SWC::Ranger::Range::TaskRunQueueScan::operator()
void operator()()
Definition: Range.cc:98
SWC::Ranger::Range::_is_any_begin
bool _is_any_begin() const
Definition: Range.cc:221
SWC::Ranger::Range::schema_update
void schema_update(bool compact)
Definition: Range.cc:231
SWC::DB::Cells::DELETE_LE
@ DELETE_LE
Definition: Cell.h:63
SWC::Ranger::Range::cfg
const ColumnCfg::Ptr cfg
Definition: Range.h:57
SWC::DB::Cell::Key::equal
constexpr SWC_CAN_INLINE bool equal(const Key &other) const noexcept
Definition: CellKey.h:179
CheckMeta.cc
SWC::Ranger::Range::can_be_merged
bool can_be_merged()
Definition: Range.cc:194
SWC::Ranger::Columns::get_column
ColumnPtr get_column(const cid_t cid)
Definition: Columns.cc:14
SWC::Ranger::RangeData::load
void load(int &err, CellStore::Readers &cellstores)
Definition: RangeData.cc:72
SWC::Ranger::Range::TaskRunQueueAdd::operator=
TaskRunQueueAdd & operator=(const TaskRunQueueAdd &)=delete
SWC::DB::Cells::Cell
Definition: Cell.h:92
SWC::Ranger::Range::wait
bool wait(uint8_t from_state=COMPACT_CHECKING, bool incr=false)
Definition: Range.cc:1084
SWC::Comm::Protocol::Rgr::Params::RangeQueryUpdateRsp::cells_added
uint32_t cells_added
Definition: RangeQueryUpdate.h:65
SWC::Ranger::CommitLog::Fragments::stopping
Core::AtomicBool stopping
Definition: CommitLog.h:32
SWC::DB::RgrData::print
void print(std::ostream &out)
Definition: RgrData.h:51
SWC::Comm::has_endpoint
bool SWC_PURE_FUNC has_endpoint(const EndPoint &e1, const EndPoints &endpoints_in) noexcept
Definition: Resolver.cc:93
SWC::Ranger::Blocks::size_bytes_total
size_t size_bytes_total(bool only_loaded=false)
Definition: RangeBlocks.cc:292
SWC::Ranger::Blocks::processing_increment
void processing_increment()
Definition: RangeBlocks.cc:40
SWC::DB::Cell::Key
Definition: CellKey.h:24
SWC::Ranger::Range::_run_add_queue
void _run_add_queue()
Definition: Range.cc:1153
SWC::DB::Cells::Cell::key
DB::Cell::Key key
Definition: Cell.h:357
SWC::DB::Cell::Serial::Value::FieldsWriter::add
SWC_CAN_INLINE void add(Field *field)
Definition: CellValueSerialFields.h:42
SWC::Ranger::Range::m_mutex_intval_alignment
Core::MutexAtomic m_mutex_intval_alignment
Definition: Range.h:183
SWC::Ranger::Blocks::commitlog
CommitLog::Fragments commitlog
Definition: RangeBlocks.h:30
SWC::Ranger::Range::m_q_add
Core::QueuePointer< Callback::RangeQueryUpdate * > m_q_add
Definition: Range.h:197
SWC::Ranger::Range::MetaRegOnAddReq::make
static SWC_CAN_INLINE Ptr make(const RangePtr &range, Callback::RangeQueryUpdate *req)
Definition: Range.cc:1114
SWC::Ranger::Range::MetaRegOnAddReq::operator=
MetaRegOnAddReq & operator=(const MetaRegOnAddReq &)=delete
SWC::Core::MutexAtomic::scope
Definition: MutexAtomic.h:77
SWC::Ranger::Range::run_add_queue
void run_add_queue()
Definition: Range.cc:1100
SWC::Ranger::CellStore::Readers::add
void add(Read::Ptr cs)
Definition: CellStoreReaders.h:48
SWC::Ranger::Range::MetaRegOnLoadReq::response
virtual void response(int err=Error::OK) override
Definition: Range.cc:41
SWC::DB::Cells::Result
Definition: Result.h:16
SWC::DB::Cell::Key::decode
void decode(const uint8_t **bufp, size_t *remainp, bool owner)
Definition: CellKey.h:337
SWC::DB::Cell::Key::add
SWC_CAN_INLINE void add(const std::string_view &fraction)
Definition: CellKey.h:86
SWC::Ranger::CellStore::create_initial
static Read::Ptr create_initial(int &err, const RangePtr &range)
Definition: CellStore.cc:610
SWC::Ranger::Blocks::init
void init(const RangePtr &for_range)
Definition: RangeBlocks.cc:20
SWC::Ranger::Range::internal_create_folders
void internal_create_folders(int &err)
Definition: Range.cc:741
SWC::Ranger::CellStore::Readers::size_bytes
size_t size_bytes(bool only_loaded=false) const
Definition: CellStoreReaders.cc:33
SWC::client::Query::Update::Handlers::Base::operator=
Base & operator=(const Base &)=delete
SWC::Ranger::Range::MetaRegOnAddReq::MetaRegOnAddReq
SWC_CAN_INLINE MetaRegOnAddReq(const RangePtr &a_range, Callback::RangeQueryUpdate *a_req)
Definition: Range.cc:1121
SWC::Ranger::Callback::RangeQueryUpdate
Definition: RangeQueryUpdate.h:17
SWC::Ranger::Range::scan
void scan(ReqScan::Ptr &&req)
Definition: Range.cc:286
SWC::Ranger::Range::internal_create
void internal_create(int &err, const CellStore::Writers &w_cellstores)
Definition: Range.cc:750
SWC::Ranger::Range::COMPACT_PREPARING
static const uint8_t COMPACT_PREPARING
Definition: Range.h:54
SWC::Ranger::Range::init
void init()
Definition: Range.cc:136
SWC::Ranger::Range::MetaRegOnLoadReq
Definition: Range.cc:21
SWC::Core::QueueSafe::push
SWC_CAN_INLINE void push(const ItemT &item)
Definition: QueueSafe.h:42
SWC::Ranger::Range::TaskRunQueueScan::~TaskRunQueueScan
~TaskRunQueueScan() noexcept
Definition: Range.cc:97
SWC::Ranger::Range::MetaRegOnAddReq::~MetaRegOnAddReq
virtual ~MetaRegOnAddReq() noexcept
Definition: Range.cc:1130
SWC::Core::QueueSafe::empty
SWC_CAN_INLINE bool empty() noexcept
Definition: QueueSafe.h:78
SWC::Ranger::Range::get_interval
void get_interval(DB::Cells::Interval &interval)
Definition: Range.cc:188
SWC::Common::Files::RgrData::get_rgr
static void get_rgr(DB::RgrData &data, const std::string &filepath) noexcept
Definition: RgrData.h:83
SWC::DB::Cell::Key::empty
constexpr SWC_CAN_INLINE bool empty() const noexcept
Definition: CellKey.h:186
SWC::Ranger::Query::Update::BaseMeta::is_last_rsp
bool is_last_rsp(int err)
Definition: BaseMeta.cc:31
SWC::Ranger::Callback::RangeUnloadInternal
Definition: RangeUnloadInternal.h:15
SWC::DB::Cells::Interval::equal
SWC_CAN_INLINE bool SWC_PURE_FUNC equal(const Interval &other) const noexcept
Definition: Interval.h:164
SWC::Ranger::Callback::RangeUnloadInternal::Ptr
std::shared_ptr< RangeUnloadInternal > Ptr
Definition: RangeUnloadInternal.h:18
SWC::Core::AtomicBase::store
constexpr SWC_CAN_INLINE void store(T v) noexcept
Definition: Atomic.h:37
SWC_CONST_FUNC
#define SWC_CONST_FUNC
Definition: Compat.h:107
SWC::Error::OK
@ OK
Definition: Error.h:45
SWC::Core::Vector::empty
constexpr SWC_CAN_INLINE bool empty() const noexcept
Definition: Vector.h:168
SWC::Ranger::RangePtr
std::shared_ptr< Range > RangePtr
Definition: Columns.h:15
SWC_CAN_INLINE
#define SWC_CAN_INLINE
Definition: Compat.h:102
SWC::LOG_DEBUG
@ LOG_DEBUG
Definition: Logger.h:36
CellValueSerialFields.h
SWC::Ranger::Query::Select::CheckMeta::run
static void run(const RangePtr &range, const Callback::RangeLoad::Ptr &req)
Definition: CheckMeta.cc:14
SWC::Ranger::Blocks::processing_decrement
void processing_decrement()
Definition: RangeBlocks.cc:45
SWC::Ranger::Range::m_path
const std::string m_path
Definition: Range.h:181
SWC::Ranger::Callback::RangeQueryUpdate::rsp
Comm::Protocol::Rgr::Params::RangeQueryUpdateRsp rsp
Definition: RangeQueryUpdate.h:21
SWC::Ranger::Query::Update::CommonMeta::Ptr
std::shared_ptr< CommonMeta > Ptr
Definition: CommonMeta.h:15
SWC::Ranger::Range::m_q_run_scan
bool m_q_run_scan
Definition: Range.h:194
RangeQueryUpdate.h
SWC::DB::Cells::Interval::aligned_min
DB::Cell::KeyVec aligned_min
Definition: Interval.h:228
SWC::Ranger::Range::State
State
Definition: Range.h:42
SWC::Ranger::Query::Update::BaseMeta
Definition: BaseMeta.h:27
SWC::Comm::Protocol::Rgr::Params::RangeQueryUpdateRsp::range_prev_end
DB::Cell::Key range_prev_end
Definition: RangeQueryUpdate.h:66
SWC::Ranger::Range::MetaRegOnAddReq::Ptr
std::shared_ptr< MetaRegOnAddReq > Ptr
Definition: Range.cc:1111
SWC::Core::Buffer::base
value_type * base
Definition: Buffer.h:131
SWC
The SWC-DB C++ namespace 'SWC'.
Definition: main.cc:12
SWC::Ranger::Range::m_state
Core::Atomic< State > m_state
Definition: Range.h:189
SWC::Ranger::Range::TaskRunQueueScan::TaskRunQueueScan
SWC_CAN_INLINE TaskRunQueueScan(TaskRunQueueScan &&other) noexcept
Definition: Range.cc:91
SWC::Ranger::Range::CELLSTORES_BAK_DIR
static constexpr const char CELLSTORES_BAK_DIR[]
Definition: Range.h:37
SWC::Ranger::Range::reset_load_revision
void reset_load_revision()
Definition: Range.cc:243
SWC::Error::RANGE_BAD_CELLS_INPUT
@ RANGE_BAD_CELLS_INPUT
Definition: Error.h:120
SWC::Ranger::CellStore::Read::make
static Ptr make(int &err, const csid_t csid, const RangePtr &range, bool chk_base=false)
Definition: CellStore.cc:13
SWC::Ranger::Range::internal_remove
void internal_remove(int &err)
Definition: Range.cc:514
SWC::Core::Buffer
Definition: Buffer.h:18
SWC::Ranger::CellStore::Readers::load_from_path
void load_from_path(int &err)
Definition: CellStoreReaders.cc:180
SWC::Ranger::Blocks::schema_update
void schema_update()
Definition: RangeBlocks.cc:31
SWC::Core::Buffer::size
size_t size
Definition: Buffer.h:130
SWC::Ranger::Range::TaskRunQueueAdd::TaskRunQueueAdd
TaskRunQueueAdd(const TaskRunQueueAdd &)=delete
SWC::Ranger::Range::m_interval
DB::Cells::Interval m_interval
Definition: Range.h:184
SWC::Ranger::Range::print
void print(std::ostream &out, bool minimal=true)
Definition: Range.cc:797
SWC::Ranger::Range::rid
const rid_t rid
Definition: Range.h:58
SWC::DB::RgrData::remove
static void remove(int &err, cid_t cid, rid_t rid) noexcept
Definition: RgrData.h:99
SWC::DB::Cells::Interval::free
void free() noexcept
Definition: Interval.cc:28
SWC::Ranger::Range::last_rgr_chk
void last_rgr_chk(int &err, const Callback::RangeLoad::Ptr &req)
Definition: Range.cc:811
SWC::DB::Cell::Key::copy
void copy(const Key &other)
Definition: CellKey.h:314
SWC::Ranger::CellStore::Readers::move_from
void move_from(int &err, Readers::Vec &mv_css)
Definition: CellStoreReaders.cc:267
SWC::DB::RangeBase::CELLSTORES_DIR
static constexpr const char CELLSTORES_DIR[]
Definition: RangeBase.h:21
SWC::Ranger::Range::TaskRunQueueAdd::TaskRunQueueAdd
SWC_CAN_INLINE TaskRunQueueAdd(TaskRunQueueAdd &&other) noexcept
Definition: Range.cc:107
SWC::DB::Cells::INSERT
@ INSERT
Definition: Cell.h:62
SWC::DB::RangeBase::LOG_DIR
static constexpr const char LOG_DIR[]
Definition: RangeBase.h:22
SWC::Ranger::Range::m_compacting
uint8_t m_compacting
Definition: Range.h:190
SWC::DB::Types::Range::MASTER
@ MASTER
SWC::DB::RangeBase::get_path_ranger
static std::string get_path_ranger(const std::string &range_path)
Definition: RangeBase.h:62
SWC::DB::RgrData::BaseUpdater
Definition: RgrData.h:165
SWC::Ranger::Range::known_interval_count
uint24_t known_interval_count()
Definition: Range.cc:180
SWC::DB::Cells::Cell::set_time_order_desc
constexpr SWC_CAN_INLINE void set_time_order_desc(bool desc) noexcept
Definition: Cell.h:169
SWC::Ranger::Range::state_unloading
bool state_unloading() const noexcept
Definition: Range.cc:274
SWC::Serialization::encoded_length_vi64
constexpr SWC_CAN_INLINE uint8_t encoded_length_vi64(uint64_t val) noexcept
Definition: Serialization.h:272
Range.h
SWC::DB::Cells::HAVE_TIMESTAMP
constexpr const uint8_t HAVE_TIMESTAMP
Definition: Cell.h:80
SWC::DB::Cell::Key::encoded_length
constexpr uint32_t encoded_length() const noexcept
Definition: CellKey.h:323
SWC::Ranger::Blocks::scan
void scan(ReqScan::Ptr req, Block::Ptr blk_ptr=nullptr)
Definition: RangeBlocks.cc:126
SWC::Ranger::Range::m_mutex
std::shared_mutex m_mutex
Definition: Range.h:187
SWC::LOG_ERROR
@ LOG_ERROR
Definition: Logger.h:32
SWC::DB::RgrData
Definition: RgrData.h:24
SWC::Ranger::Range::internal_unload
void internal_unload(bool completely, bool &chk_empty)
Definition: Range.cc:440
SWC_FMT_LU
#define SWC_FMT_LU
Definition: Compat.h:98
SWC::DB::RgrData::BaseSelector
Definition: RgrData.h:237
SWC::Ranger::Range::COMPACT_NONE
static const uint8_t COMPACT_NONE
Definition: Range.h:51
SWC::Ranger::Query::Update::BaseMeta::Ptr
std::shared_ptr< BaseMeta > Ptr
Definition: BaseMeta.h:29
SWC::Core::NotMovableSharedPtr< ColumnCfg >
SWC::Core::AtomicBase::exchange
constexpr SWC_CAN_INLINE T exchange(T value) noexcept
Definition: Atomic.h:47
SWC::DB::Cell::Serial::Value::FieldsWriter
Definition: CellValueSerialFields.h:34
SWC::Ranger::to_string
const char *SWC_CONST_FUNC to_string(Range::State state) noexcept
Definition: Range.cc:68
SWC::Ranger::Range::get_path_cs
std::string get_path_cs(const csid_t csid) const
Definition: Range.cc:153
SWC::Ranger::Range::scan_internal
void scan_internal(ReqScan::Ptr &&req)
Definition: Range.cc:353
SWC::Ranger::Blocks::apply_new
void apply_new(int &err, CellStore::Writers &w_cellstores, CommitLog::Fragments::Vec &fragments_old)
Definition: RangeBlocks.cc:94
SWC::client::Query::Update::Handlers::Base::error
virtual int error() noexcept
Definition: Base.h:159
SWC::Ranger::Range::is_loaded
bool is_loaded()
Definition: Range.cc:253
SWC::Ranger::Range::MetaRegOnAddReq::response
virtual void response(int err=Error::OK) override
Definition: Range.cc:1132
SWC::Ranger::Range::COMPACT_APPLYING
static const uint8_t COMPACT_APPLYING
Definition: Range.h:55
SWC::Ranger::Blocks::cellstores
CellStore::Readers cellstores
Definition: RangeBlocks.h:31
SWC::Core::Vector< Write::Ptr >
SWC::Ranger::Range::on_change
void on_change(bool removal, const Query::Update::BaseMeta::Ptr &hdlr, const DB::Cell::Key *old_key_begin=nullptr)
Definition: Range.cc:614
SWC::Ranger::Range::TaskRunQueueAdd::operator()
void operator()()
Definition: Range.cc:114
SWC::Ranger::Range::TaskRunQueueScan
Definition: Range.cc:86
SWC::Ranger::Blocks::processing
bool processing() noexcept
Definition: RangeBlocks.cc:371
SWC::Core::BufferDyn::fill
constexpr SWC_CAN_INLINE size_t fill() const noexcept
Definition: Buffer.h:192
SWC::Common::Files::RgrData::set_rgr
static void set_rgr(const DB::RgrData &data, int &err, std::string &&filepath, uint8_t replication) noexcept
Definition: RgrData.h:49
SWC::Ranger::Range::MetaRegOnAddReq::operator=
MetaRegOnAddReq & operator=(MetaRegOnAddReq &&)=delete
SWC::DB::Cells::Interval::copy
void copy(const Interval &other)
Definition: Interval.cc:16
SWC::Ranger::Range::m_mutex_intval
Core::MutexAtomic m_mutex_intval
Definition: Range.h:182
SWC::DB::Cell::Key::count
uint24_t count
Definition: CellKey.h:255
SWC::uint24_t
Core::uint24_t uint24_t
Definition: BitFieldInt.h:401
SWC::Ranger::Range::compact_apply
bool compact_apply()
Definition: Range.cc:547
SWC::Ranger::CommitLog::Fragments::commit
void commit() noexcept
Definition: CommitLog.cc:59
SWC::Ranger::Range::MetaRegOnAddReq::MetaRegOnAddReq
MetaRegOnAddReq(MetaRegOnAddReq &&)=delete
SWC::Core::AtomicBase::load
constexpr SWC_CAN_INLINE T load() const noexcept
Definition: Atomic.h:42
SWC::Ranger::Callback::ColumnDelete::Ptr
std::shared_ptr< ColumnDelete > Ptr
Definition: ColumnDelete.h:16
SWC::DB::Types::MngrColumn::LOADING
@ LOADING
Definition: MngrColumnState.h:19
SWC::DB::Cell::Serial::Value::skip_type_and_id
SWC_CAN_INLINE void skip_type_and_id(const uint8_t **bufp, size_t *remainp)
Definition: CellValueSerialField.h:61
SWC::DB::Cell::KeyVec::copy
void copy(const KeyVec &other)
Definition: CellKeyVec.h:181
SWC::Ranger::Range::m_q_run_add
bool m_q_run_add
Definition: Range.h:193
SWC::Ranger::Blocks::unload
void unload()
Definition: RangeBlocks.cc:55
SWC::Error::COLUMN_MARKED_REMOVED
@ COLUMN_MARKED_REMOVED
Definition: Error.h:102
SWC::Env::Rgr::is_shuttingdown
static SWC_CAN_INLINE bool is_shuttingdown() noexcept
Definition: RangerEnv.h:58
SWC::Ranger::Range::m_load_revision
Core::Atomic< int64_t > m_load_revision
Definition: Range.h:185
SWC::Ranger::Range::TaskRunQueueAdd::TaskRunQueueAdd
SWC_CAN_INLINE TaskRunQueueAdd(const RangePtr &a_ptr) noexcept
Definition: Range.cc:104
RangeUnload.cc
SWC::Ranger::Range::remove
void remove(const Callback::ColumnDelete::Ptr &req)
Definition: Range.cc:480
SWC::Serialization::decode_vi64
constexpr SWC_CAN_INLINE uint64_t decode_vi64(const uint8_t **bufp, size_t *remainp)
Definition: Serialization.h:302
SWC::Ranger::Blocks::expand
void expand(DB::Cells::Interval &intval)
Definition: RangeBlocks.cc:83
SWC::Ranger::Range::MetaRegOnAddReq::MetaRegOnAddReq
MetaRegOnAddReq(const MetaRegOnAddReq &)=delete
SWC::Ranger::Range::prev_range_end
DB::Cell::Key prev_range_end
Definition: Range.h:60
SWC::Ranger::Range::set_rgr
void set_rgr(int &err) const noexcept
Definition: Range.cc:163
SWC::Ranger::Range::TaskRunQueueScan::operator=
TaskRunQueueScan & operator=(TaskRunQueueScan &&)=delete
SWC::DB::Cells::Interval::ts_earliest
Specs::Timestamp ts_earliest
Definition: Interval.h:226
SWC::rid_t
uint64_t rid_t
Definition: Identifiers.h:17
SWC::Ranger::Range::TaskRunQueueAdd::~TaskRunQueueAdd
~TaskRunQueueAdd() noexcept
Definition: Range.cc:113
SWC::Ranger::Range::state
void state(int &err) const
Definition: Range.cc:265
SWC::Ranger::Callback::RangeQueryUpdate::response
SWC_CAN_INLINE void response()
Definition: RangeQueryUpdate.h:41
SWC::DB::Cell::KeyVec::equal
bool equal(const KeyVec &other) const noexcept
Definition: CellKeyVec.h:187
SWC::Ranger::Range::m_require_compact
Core::AtomicBool m_require_compact
Definition: Range.h:191
SWC::Ranger::Range::compact_require
void compact_require(bool require)
Definition: Range.cc:605
SWC::DB::Cells::Result::print
void print(std::ostream &out, Types::Column col_type=Types::Column::PLAIN, bool with_cells=false) const
Definition: Result.cc:64
SWC::Ranger::Callback::RangeLoad::Ptr
std::shared_ptr< RangeLoad > Ptr
Definition: RangeLoad.h:16
SWC::Ranger::Range::compacting_ifnot_applying
bool compacting_ifnot_applying(uint8_t state)
Definition: Range.cc:573
SWC::Ranger::Range::set_state
void set_state(State new_state)
Definition: Range.cc:237
SWC::Env::Rgr::is_not_accepting
static SWC_CAN_INLINE bool is_not_accepting() noexcept
Definition: RangerEnv.h:53
SWC::DB::RgrData::endpoints
Comm::EndPoints endpoints
Definition: RgrData.h:29
SWC::DB::Types::MngrColumn::DELETED
@ DELETED
Definition: MngrColumnState.h:20
SWC::LOG_WARN
@ LOG_WARN
Definition: Logger.h:33
SWC::Ranger::Range::get_load_revision
int64_t get_load_revision()
Definition: Range.cc:248
SWC::DB::Cell::Key::print
void print(std::ostream &out) const
Definition: CellKey.cc:182
SWC::Ranger::Range::TaskRunQueueScan::TaskRunQueueScan
SWC_CAN_INLINE TaskRunQueueScan(RangePtr &&a_ptr) noexcept
Definition: Range.cc:89
SWC::Ranger::Range::MetaRegOnAddReq::callback
virtual void callback() override
Definition: Range.cc:1137
SWC::Ranger::Blocks::add_logged
void add_logged(const DB::Cells::Cell &cell)
Definition: RangeBlocks.cc:111
SWC::DB::Cell::Key::remove
void remove(uint32_t idx, bool recursive=false)
Definition: CellKey.cc:94
SWC::Ranger::Blocks::print
void print(std::ostream &out, bool minimal)
Definition: RangeBlocks.cc:403
SWC::Comm::Protocol::Rgr::Req::RangeUnload
Definition: RangeUnload.h:15
SWC::Ranger::Range::_is_any_end
bool _is_any_end() const
Definition: Range.cc:226
SWC::Ranger::Blocks::range
RangePtr range
Definition: RangeBlocks.h:29
SWC::Ranger::Range::wait_queue
void wait_queue()
Definition: Range.cc:535
SWC::Ranger::Range::m_cv
std::condition_variable_any m_cv
Definition: Range.h:200
SWC::Error::RANGE_BAD_INTERVAL
@ RANGE_BAD_INTERVAL
Definition: Error.h:119
SWC::Ranger::Range::MetaRegOnAddReq
Definition: Range.cc:1109
SWC::Env::Rgr::post
static SWC_CAN_INLINE void post(T_Handler &&handler)
Definition: RangerEnv.h:114
SWC::DB::Types::Column::SERIAL
@ SERIAL
SWC::Ranger::Range::TaskRunQueueAdd::operator=
TaskRunQueueAdd & operator=(TaskRunQueueAdd &&)=delete
SWC::Ranger::Query::Update::BaseMeta::range
RangePtr range
Definition: BaseMeta.h:31
SWC::Ranger::Range::MetaRegOnLoadReq::~MetaRegOnLoadReq
virtual ~MetaRegOnLoadReq() noexcept
Definition: Range.cc:39
SWC::Comm::Protocol::Rgr::Params::RangeQueryUpdateRsp::err
int32_t err
Definition: RangeQueryUpdate.h:64
SWC::Comm::Protocol::Rgr::Req::RangeUnload::Ptr
std::shared_ptr< RangeUnload > Ptr
Definition: RangeUnload.h:17
SWC::Core::Atomic::fetch_sub
constexpr SWC_CAN_INLINE T fetch_sub(T v) noexcept
Definition: Atomic.h:88
SWC::DB::Cells::Interval
Definition: Interval.h:17
SWC_ASSERT
#define SWC_ASSERT(_e_)
Definition: Exception.h:165
SWC::Ranger::Callback::RangeQueryUpdate::expired
SWC_CAN_INLINE bool expired() const
Definition: RangeQueryUpdate.h:36
SWC::Error::print
void print(std::ostream &out, int err)
Definition: Error.cc:191
SWC::Ranger::Query::Update::BaseMeta::BaseMeta
BaseMeta(const RangePtr &range)
Definition: BaseMeta.cc:14
SWC::Error::CANCELLED
@ CANCELLED
Definition: Error.h:56
SWC::Core::Atomic::fetch_add
constexpr SWC_CAN_INLINE T fetch_add(T v) noexcept
Definition: Atomic.h:93
SWC::Ranger::Range::compact_possible
bool compact_possible(bool minor=true)
Definition: Range.cc:595
SWC::DB::Cells::Interval::ts_latest
Specs::Timestamp ts_latest
Definition: Interval.h:227
SWC::Ranger::Range::MetaRegOnLoadReq::make
static SWC_CAN_INLINE Ptr make(const RangePtr &range, const Callback::RangeLoad::Ptr &req)
Definition: Range.cc:26
SWC::Ranger::Range::MetaRegOnAddReq::req
Callback::RangeQueryUpdate * req
Definition: Range.cc:1118
SWC::Core::Vector::size
constexpr SWC_CAN_INLINE size_type size() const noexcept
Definition: Vector.h:189
SWC::DB::Types::SystemColumn::is_rgr_data_on_fs
constexpr SWC_CAN_INLINE bool is_rgr_data_on_fs(cid_t cid) noexcept
Definition: SystemColumn.h:41
SWC::Ranger::Range::compact_required
bool compact_required()
Definition: Range.cc:610
SWC::DB::RgrData::get_rgr
static void get_rgr(const SyncSelector::Ptr &hdlr, RgrData &data, cid_t cid, rid_t rid) noexcept
Definition: RgrData.h:318
SWC::Ranger::ReqScan::Ptr
std::shared_ptr< ReqScan > Ptr
Definition: ReqScan.h:30
SWC_LOG_CURRENT_EXCEPTION
#define SWC_LOG_CURRENT_EXCEPTION(_s_)
Definition: Exception.h:144
SWC::Ranger::Range::blocks
Blocks blocks
Definition: Range.h:59
SWC::Ranger::Range::_get_interval
void _get_interval(DB::Cells::Interval &interval) const
Definition: Range.cc:209
SWC::Ranger::Range::m_adding
Core::Atomic< uint32_t > m_adding
Definition: Range.h:196
SWC::DB::RgrData::set_rgr
void set_rgr(int &err, cid_t cid, rid_t rid) noexcept
Definition: RgrData.h:87
SWC::Ranger::Query::Select::CheckMeta::Ptr
std::shared_ptr< CheckMeta > Ptr
Definition: CheckMeta.h:33
SWC::Ranger::CellStore::Readers::get_prev_key_end
void get_prev_key_end(uint32_t idx, DB::Cell::Key &key) const
Definition: CellStoreReaders.cc:122
SWC::Ranger::Callback::RangeQueryUpdate::ev
Comm::Event::Ptr ev
Definition: RangeQueryUpdate.h:20
SWC::Core::Vector::reserve
SWC_CAN_INLINE void reserve(size_type cap)
Definition: Vector.h:288
SWC::Comm::equal_endpoints
bool SWC_PURE_FUNC equal_endpoints(const EndPoints &endpoints1, const EndPoints &endpoints2) noexcept
Definition: Resolver.cc:108
SWC::DB::Cells::Cell::flag
uint8_t flag
Definition: Cell.h:359
SystemColumn.h
SWC::DB::KeySeq::compare
Condition::Comp compare(const Types::KeySeq seq, const Cell::Key &key, const Cell::Key &other) SWC_ATTRIBS((SWC_ATTRIB_O3))
Definition: KeyComparator.h:294
SWC::Ranger::Blocks::load
void load(int &err)
Definition: RangeBlocks.cc:50
SWC::DB::Cells::Interval::key_begin
DB::Cell::Key key_begin
Definition: Interval.h:224
SWC::DB::Cell::KeyVec::decode
void decode(const uint8_t **bufp, size_t *remainp)
Definition: CellKeyVec.h:234
SWC::DB::Cells::Interval::was_set
bool was_set
Definition: Interval.h:230
SWC::Ranger::Range::MetaRegOnLoadReq::MetaRegOnLoadReq
SWC_CAN_INLINE MetaRegOnLoadReq(const RangePtr &a_range, const Callback::RangeLoad::Ptr &a_req)
Definition: Range.cc:34
SWC::Comm::Protocol::Rgr::Params::RangeQueryUpdateRsp::range_end
DB::Cell::Key range_end
Definition: RangeQueryUpdate.h:67
SWC::Env::Rgr::get
static SWC_CAN_INLINE Rgr * get() noexcept
Definition: RangerEnv.h:98
SWC::Ranger::Range::TaskRunQueueAdd::TaskRunQueueAdd
TaskRunQueueAdd(RangePtr &&a_ptr) noexcept
Definition: Range.cc:105
SWC::Core::QueueSafe::pop
SWC_CAN_INLINE bool pop(ItemT *item)
Definition: QueueSafe.h:97
SWC::Ranger::Query::Update::CommonMeta::make
static SWC_CAN_INLINE Ptr make(const RangePtr &range, Cb_t &&cb)
Definition: CommonMeta.h:19