SWC-DB  v0.5.12 C++ documentations
SWC-DB© (Super Wide Column Database) - High Performance Scalable Database (https://github.com/kashirin-alex/swc-db)
MngdColumns.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 
7 #include "swcdb/core/Semaphore.h"
10 
15 
16 
17 namespace SWC { namespace Manager {
18 
20 
21 
23  : cfg_schema_replication(
24  Env::Config::settings()->get<Config::Property::Value_uint8_g>(
25  "swc.mngr.schema.replication")),
26  cfg_schemas_store_cap(
27  Env::Config::settings()->get<Config::Property::Value_uint64_g>(
28  "swc.mngr.schemas.store.from.capacity")),
29  cfg_schemas_store_blksz(
30  Env::Config::settings()->get<Config::Property::Value_int32_g>(
31  "swc.mngr.schemas.store.block.size")),
32  cfg_schemas_store_encoder(
33  Env::Config::settings()->get<Config::Property::Value_enum_g>(
34  "swc.mngr.schemas.store.block.encoder")),
35  cfg_delay_cols_init(
36  Env::Config::settings()->get<Config::Property::Value_int32_g>(
37  "swc.mngr.ranges.assign.delay.afterColumnsInit")),
38  m_run(true), m_columns_load(),
39  m_mutex_schemas(), m_schemas_set(false),
40  m_mutex_active(), m_cid_active(false),
41  m_cid_begin(DB::Schema::NO_CID), m_cid_end(DB::Schema::NO_CID),
42  m_expected_remain(STATE_COLUMNS_NOT_INITIALIZED),
43  m_last_used_cid(DB::Types::SystemColumn::SYS_CID_END),
44  m_expected_load(),
45  m_mutex_actions(), m_actions(), m_actions_pending() {
46 }
47 
49  SWC_LOG(LOG_INFO, "Stopping MngdColumns");
50  m_run.store(false);
51  {
54  }
55  bool expecting = false;
56  size_t pending = 0;
57  for(size_t c=0; ; ++c) {
58  if(m_actions.empty() && !m_columns_load) {
59  {
61  expecting = !m_expected_load.empty();
62  }
63  {
65  pending = m_actions_pending.size();
66  }
67  if(!expecting && !pending)
68  break;
69  }
70  std::this_thread::sleep_for(std::chrono::milliseconds(10));
71  if(c % 1000 == 0)
73  "Stop-Waiting colums load=%s actions=" SWC_FMT_LU
74  " expecting=%s pending=" SWC_FMT_LU,
75  m_columns_load ? "True" : "False", m_actions.size(),
76  expecting ? "True" : "False", pending);
77  }
78 }
79 
81  int err = Error::OK;
82  if(is_schemas_mngr(err) && (!err || err == Error::SERVER_SHUTTING_DOWN) &&
85  err,
89  );
92  << "Create Schemas-Store schemas=" << Env::Mngr::schemas()->size();
93  Error::print(SWC_LOG_OSTREAM << ' ', err);
94  );
95  }
96 }
97 
98 void MngdColumns::reset(bool schemas_mngr) {
99  if(schemas_mngr) {
100  {
102  m_schemas_set.store(false);
103  }
104  {
106  if(m_cid_active)
107  return;
108  }
111  }
112 }
113 
114 
117  if(Env::Mngr::role()->is_active_role(DB::Types::MngrRole::SCHEMAS)) {
118  if(m_schemas_set) {
120  if(m_schemas_set) {
121  if(!m_run)
123  return true;
124  }
125  }
127  return true;
128  }
129  return false;
130 }
131 
133 bool MngdColumns::has_active() noexcept {
135  return m_cid_active;
136 }
137 
139 bool MngdColumns::is_active(cid_t cid) noexcept {
140  Core::MutexSptd::scope lock(m_mutex_active);
141  return m_cid_active && cid &&
142  (!m_cid_begin || m_cid_begin <= cid) &&
143  (!m_cid_end || m_cid_end >= cid);
144 }
145 
146 bool MngdColumns::active(cid_t& cid_begin, cid_t& cid_end) noexcept {
147  Core::MutexSptd::scope lock(m_mutex_active);
148  if(m_cid_active) {
149  cid_begin = m_cid_begin;
150  cid_end = m_cid_end;
151  }
152  return m_cid_active;
153 }
154 
158  return m_expected_remain == 0;
159 }
160 
162  {
164  if(!m_cid_active)
165  return;
166  if(m_expected_remain > 0) {
168  return;
169  }
170  }
171  Env::Mngr::columns()->state(err);
172 }
173 
175  Column::Ptr col;
176  if(!is_active(cid)) {
178  return col;
179  }
180  if(is_schemas_mngr(err) && err)
181  return col;
182 
183  if((col = Env::Mngr::columns()->get_column(err, cid))) {
184  col->state(err);
185  } else {
186  err = expected_ready()
189  }
190  return col;
191 }
192 
193 void MngdColumns::change_active(const cid_t cid_begin, const cid_t cid_end,
194  bool has_cols) {
195  if(!has_cols) {
196  {
198  if(!m_cid_active)
199  return;
200  m_cid_active = false;
202  }
203 
206  if(!Env::Mngr::role()->is_active_role(DB::Types::MngrRole::SCHEMAS))
208  return;
209  }
210 
211  {
213  if(m_cid_active && cid_begin == m_cid_begin && cid_end == m_cid_end)
214  return;
215  m_cid_begin = cid_begin;
216  m_cid_end = cid_end;
217  m_cid_active = true;
219  }
220 
221  if(m_run)
223 
224  //if(Env::Mngr::role()->is_active_role(DB::Types::MngrRole::SCHEMAS))
225  // (scheduled on column changes ) + chk(cid) LOAD_ACK
226 }
227 
228 
231 
232  if(!columns_load())
233  update(
234  ColumnMngFunc::INTERNAL_LOAD_ALL, DB::Schema::make(), Error::OK, 0);
235 }
236 
239  struct Task {
240  MngdColumns* ptr;
242  Task(MngdColumns* a_ptr) noexcept : ptr(a_ptr) { }
243  void operator()() { ptr->run_actions(); }
244  };
245  if(m_actions.push_and_is_1st(req))
246  Env::Mngr::post(Task(this));
247 }
248 
249 void MngdColumns::set_expect(cid_t cid_begin, cid_t cid_end, uint64_t total,
250  cids_t&& columns, bool initial) {
251  if(!initial &&
253  return;
254 
255  bool active;
256  {
258  active = m_cid_active && m_cid_begin == cid_begin && m_cid_end == cid_end;
259  }
260  if(!active)
264  cid_begin, cid_end, total, std::move(columns))
265  )
266  );
267 
268  size_t need = STATE_COLUMNS_NOT_INITIALIZED;
269  if(m_run) {
270  int err;
271  auto _cols = Env::Mngr::columns();
273  if(m_expected_remain == 0 || m_expected_remain == need || total == need)
274  m_expected_remain = total;
275  for(auto cid : columns) {
276  if(std::find(m_expected_load.cbegin(), m_expected_load.cend(), cid)
277  == m_expected_load.cend() &&
278  !_cols->get_column(err = Error::OK, cid)) {
279  m_expected_load.push_front(cid);
280  } else {
283  "Expected Column(" SWC_FMT_LU ") was Loaded remain=" SWC_FMT_LU,
284  cid, m_expected_remain);
285  }
286  }
287  need = m_expected_remain;
288  }
289  if(need) {
290  if(need == STATE_COLUMNS_NOT_INITIALIZED) {
292  "Expected Columns to Load CANCELLED for cid(begin=" SWC_FMT_LU
293  " end=" SWC_FMT_LU ")",
294  cid_begin, cid_end);
295  } else {
297  "Expected Columns to Load size=" SWC_FMT_LU "/" SWC_FMT_LU
298  " for cid(begin=" SWC_FMT_LU " end=" SWC_FMT_LU ")",
299  need, total, cid_begin, cid_end);
300  }
301  }
302 }
303 
305  const DB::Schema::Ptr& schema, int err,
306  uint64_t req_id, bool initial) {
307  bool schemas_mngr = Env::Mngr::role()->is_active_role(
309 
310  if(!initial && schemas_mngr)
311  return update_status_ack(func, schema, err, req_id);
312 
313  err = Error::OK;
314  if(!is_active(schema->cid))
315  return update(func, schema, err, req_id);
316 
318  SWC_LOG_OSTREAM << "ColumnUpdate Request func=" << int(func)
319  << " req_id=" << req_id;
320  schema->print(SWC_LOG_OSTREAM << ' ');
321  );
322 
323  bool do_update = false;
324  switch(func) {
325 
326  case ColumnMngFunc::REMOVE: {
327  auto col = get_column(err, schema->cid);
328  if(err &&
329  err != Error::COLUMN_NOT_EXISTS &&
330  err != Error::COLUMN_NOT_READY) {
331  do_update = true;
332 
333  } else if(!col) {
334  err = Error::OK;
335  remove(schema, 0, req_id);
336  do_update = true;
337 
338  } else if(!col->do_remove()) {
339  do_update = true;
340 
341  } else {
342  SWC_LOGF(LOG_DEBUG, "DELETING cid=" SWC_FMT_LU, schema->cid);
343  Core::Vector<rgrid_t> rgrids;
344  col->assigned(rgrids);
345  do_update = rgrids.empty();
346  if(do_update)
347  remove(schema, 0, req_id);
348  else
349  Env::Mngr::rangers()->column_delete(schema, req_id, rgrids);
350  }
351  break;
352  }
353 
354  case ColumnMngFunc::CREATE:
355  case ColumnMngFunc::INTERNAL_LOAD: {
356  bool init = m_run &&
358  if(init || !err || !m_run) {
359  if(!schemas_mngr)
360  Env::Mngr::schemas()->replace(schema);
361  {
363  if(m_expected_load.remove(schema->cid)) {
364  init = m_run;
368  "Expected Column(" SWC_FMT_LU ") Loaded remain=" SWC_FMT_LU,
369  schema->cid, m_expected_remain);
370  }
371  }
372  }
373  }
374  if(init)
376 
377  do_update = true;
378  break;
379  }
380 
381  case ColumnMngFunc::MODIFY: {
382  do_update = true;
383  auto col = Env::Mngr::columns()->get_column(err, schema->cid);
384  err = Error::OK;
385  if(col && !schemas_mngr) {
386  auto existing = Env::Mngr::schemas()->get(schema->cid);
387  if((do_update = !existing || !existing->equal(schema)))
388  Env::Mngr::schemas()->replace(schema);
389  }
390  do_update = col && do_update &&
391  !Env::Mngr::rangers()->update(col, schema, req_id, true);
392  break;
393  }
394 
395  default:
396  break;
397  }
398 
399  if(do_update) {
400  auto co_func = ColumnMngFunc(uint8_t(func)+1);
401  schemas_mngr
402  ? update_status_ack(co_func, schema, err, req_id)
403  : update(co_func, schema, err, req_id);
404  }
405 }
406 
408  rgrid_t rgrid, uint64_t req_id) {
409  {
410  int err = Error::OK;
411  auto col = Env::Mngr::columns()->get_column(err, schema->cid);
412  if(col && !col->finalize_remove(err, rgrid))
413  return;
414  }
415 
416  Env::Mngr::rangers()->wait_health_check(schema->cid);
417 
418  Env::Mngr::columns()->remove(schema->cid);
419  if(!Env::Mngr::role()->is_active_role(DB::Types::MngrRole::SCHEMAS))
420  Env::Mngr::schemas()->remove(schema->cid);
421 
422  if(DB::Types::SystemColumn::is_master(schema->cid))
423  return update(
424  ColumnMngFunc::INTERNAL_ACK_DELETE, schema, Error::OK, req_id);
425 
428  [this, req_id, schema]
431  schema->col_seq,
433  );
434  DB::Cells::Result cells_meta;
435  DB::Cells::Result cells_rgrdata;
436  int err = _hdlr->state_error;
437  if(!err) {
438  auto col = _hdlr->get_columnn(meta_cid);
439  if(!(err = col->error()) && !col->empty())
440  col->get_cells(cells_meta);
441 
442  col = _hdlr->get_columnn(DB::Types::SystemColumn::SYS_RGR_DATA);
443  if(!col->error() && !col->empty())
444  col->get_cells(cells_rgrdata);
445  }
446  if(err) {
448  "Column(cid=" SWC_FMT_LU " meta_cid=" SWC_FMT_LU ") "
449  "Range MetaData might remained, result-err=%d(%s)",
450  schema->cid, meta_cid, err, Error::get_text(err));
451  }
452  if(!cells_meta.empty() || !cells_rgrdata.empty()) {
454  SWC_LOG_OSTREAM << "Column(cid=" << schema->cid << ')'
455  << " deleted Ranges MetaData:\n meta_cid=" << meta_cid
456  << " remained(" << cells_meta.size() << ") cells=[";
457  for(auto cell : cells_meta)
458  cell->key.print(SWC_LOG_OSTREAM << "\n\t");
459  SWC_LOG_OSTREAM << "\n ]\n SYS_RGR_DATA"
460  << " remained(" << cells_rgrdata.size() << ") cells=[";
461  for(auto cell : cells_rgrdata)
462  cell->key.print(SWC_LOG_OSTREAM << "\n\t");
463  SWC_LOG_OSTREAM << "\n ]";
464  );
465  }
466  return update(
467  ColumnMngFunc::INTERNAL_ACK_DELETE, schema, Error::OK, req_id);
468  },
469  false,
470  Env::Mngr::io()
471  );
472 
474  spec.set_opt__deleting();
475  spec.flags.set_only_keys();
476  auto& key_intval = spec.key_intervals.add();
477  key_intval.start.reserve(2);
478  key_intval.start.add(std::to_string(schema->cid), Condition::EQ);
479  key_intval.start.add("", Condition::FIP);
480 
482  schema->col_seq, DB::Types::SystemColumn::get_range_type(schema->cid));
484  hdlr->scan(schema->col_seq, meta_cid, std::move(spec));
485  } else {
486  hdlr->completion.increment();
487  hdlr->scan(schema->col_seq, meta_cid, spec);
488  spec.values.col_type = DB::Types::Column::PLAIN;
489  hdlr->scan(
490  DB::Types::KeySeq::VOLUME,
492  std::move(spec)
493  );
494  if(hdlr->completion.is_last())
495  hdlr->response(Error::OK);
496  }
497 }
498 
499 
500 void MngdColumns::print(std::ostream& out) {
501  Env::Mngr::columns()->print(out);
502 }
503 
506  if(m_schemas_set)
507  return false;
508 
509  SWC_LOG(LOG_INFO, "Load-Schemas START");
510  int err = Error::OK;
511  try {
512  if(Env::Mngr::schemas()->store_load(err)) {
513  m_schemas_set.store(true);
514  SWC_LOGF(LOG_INFO, "Load-Schemas FINISH schemas=" SWC_FMT_LU,
515  Env::Mngr::schemas()->size());
516  return true;
517  }
518  if(err) {
520  SWC_LOG_OSTREAM << "Problem loading Schemas-Store ";
522  );
523  }
524  } catch(...) {
526  }
527 
528  FS::IdEntries_t entries;
529  Columns::columns_by_fs(err = Error::OK, entries);
530  if(err || !m_run) {
531  if(err != ENOENT)
532  return false;
533  err = Error::OK;
534  }
535  // initialize / recover sys-columns
536  for(cid_t cid=1; cid <= DB::Types::SystemColumn::SYS_CID_END; ++cid) {
537  if(std::find(entries.cbegin(), entries.cend(), cid) == entries.cend()) {
538  Column::create(err, cid);
539  entries.push_back(cid);
540  }
541  }
542 
543  uint32_t sz = Env::Mngr::res().concurrency() / 2;
544  Core::Semaphore pending(sz ? sz : 1, 1);
545  int32_t vol = entries.size()/pending.available() + 1;
546  auto it = entries.cbegin();
548 
549  struct Task {
550  MngdColumns* ptr;
551  Core::Semaphore* pending;
554  uint8_t replicas;
556  Task(MngdColumns* a_ptr,
557  Core::Semaphore* a_pending,
560  uint8_t a_replicas) noexcept
561  : ptr(a_ptr), pending(a_pending),
562  it_begin(a_it_begin), it_end(a_it_end),
563  replicas(a_replicas) {
564  }
565  void operator()() {
566  DB::Schema::Ptr schema;
567  int err;
568  for(cid_t cid; ptr->m_run && it_begin != it_end; ++it_begin) {
569  cid = *it_begin;
570  SWC_LOGF(LOG_DEBUG, "Schema Loading cid=" SWC_FMT_LU, cid);
571  schema = Common::Files::Schema::load(err=Error::OK, cid, replicas);
572  if(!err)
573  Env::Mngr::schemas()->add(err, schema);
574  else
575  SWC_LOGF(LOG_ERROR, "Schema cid=" SWC_FMT_LU " err=%d(%s)",
576  cid, err, Error::get_text(err));
577  }
578  pending->release();
579  }
580  };
581  do {
582  pending.acquire();
583  it_to = entries.cend() - it > vol ? (it + vol) : entries.cend();
585  Task(this, &pending, it, it_to, cfg_schema_replication->get()));
586  it += it_to - it;
587  } while(m_run && it_to != entries.cend());
588 
589  pending.release();
590  pending.wait_all();
591 
592  if(m_run) {
593  m_schemas_set.store(true);
594  SWC_LOGF(LOG_INFO, "Load-Schemas FINISH schemas=" SWC_FMT_LU,
595  Env::Mngr::schemas()->size());
596  return true;
597  } else {
599  SWC_LOG(LOG_INFO, "Load-Schemas CANCLLED");
600  return false;
601  }
602 }
603 
604 
606  if(m_columns_load.running())
607  return true;
608  for(int err;;) {
609  if(is_schemas_mngr(err = Error::OK) && m_run) {
610  if(err) // hold-on
611  std::this_thread::sleep_for(std::chrono::milliseconds(100));
612  else
613  break;
614  } else {
616  return false;
617  }
618  }
619 
620  auto groups = Env::Clients::get()->managers.groups->get_groups();
621  if(groups.empty())
622  SWC_LOG(LOG_WARN, "Empty Managers Groups")
623 
624  DB::SchemasVec entries;
625  Env::Mngr::schemas()->all(entries);
626  if(entries.empty())
627  SWC_LOG(LOG_WARN, "Empty Schema Entries")
628 
629  if(!m_run || groups.empty() || entries.empty()) {
631  return false;
632  }
633 
634  std::sort(groups.begin(), groups.end(), []
635  (const client::Mngr::Group::Ptr& g1, const client::Mngr::Group::Ptr& g2) {
636  return (!g1->cid_begin || g1->cid_begin < g2->cid_begin) &&
637  (g2->cid_end && g1->cid_end < g2->cid_end); });
638 
639  while(!Env::Mngr::role()->are_all_active(groups) && m_run)
640  std::this_thread::sleep_for(std::chrono::milliseconds(100)); // hold-on
641 
642  std::sort(entries.begin(), entries.end(),
643  [](const DB::Schema::Ptr& s1, const DB::Schema::Ptr& s2) {
644  return s1->cid < s2->cid; });
645 
646  auto it = entries.cbegin();
647  auto it_batch = it;
648  size_t g_batches;
649  for(auto& g : groups) {
650  if(!m_run) {
652  return false;
653  }
654  if(!(g->role & DB::Types::MngrRole::COLUMNS))
655  continue;
656  uint64_t total = 0;
657  for(auto itc = it;
658  itc != entries.cend() &&
659  (!g->cid_begin || g->cid_begin <= (*itc)->cid) &&
660  (!g->cid_end || g->cid_end >= (*itc)->cid); ++itc) {
661  ++total;
662  }
663  g_batches = 0;
664  cids_t columns;
665 
666  make_batch:
667  it_batch = it;
668  columns.reserve(1000);
669  for(;it != entries.cend() && columns.size() < 1000 &&
670  (!g->cid_begin || g->cid_begin <= (*it)->cid) &&
671  (!g->cid_end || g->cid_end >= (*it)->cid); ++it) {
672  columns.push_back((*it)->cid);
673  }
674  if(++g_batches > 1 && columns.empty())
675  continue;
676 
677  int64_t sz = columns.size();
679  "Set Expected Columns Load cid(begin=" SWC_FMT_LU " end=" SWC_FMT_LU ") "
680  SWC_FMT_LU "(" SWC_FMT_LD "/" SWC_FMT_LU ")",
681  g->cid_begin, g->cid_end, g_batches, sz, total);
682  set_expect(g->cid_begin, g->cid_end, total, std::move(columns), true);
683  columns.clear();
684 
685  for(; it_batch != it; ++it_batch) {
687  "Set Expected Load cid(" SWC_FMT_LU ")", (*it_batch)->cid);
689  ColumnMngFunc::INTERNAL_LOAD, *it_batch, Error::OK, 0, true);
690  }
691  if(!m_run) {
692  // Cancel Expectations
693  set_expect(
694  g->cid_begin, g->cid_end,
696  );
698  return false;
699  }
700  if(it != entries.cend() && sz == 1000)
701  goto make_batch;
702  }
703 
705  return true;
706 }
707 
709  for(cid_t cid; ;) {
710  cid = m_last_used_cid.add_rslt(1);
713  m_last_used_cid.store(++cid);
714  }
715  if(!Env::Mngr::schemas()->get(cid)) {
716  // if schema does exist on fs (? sanity-check)
717  return cid; // err !cid
718  }
719  }
720 }
721 
722 void MngdColumns::create(int &err, DB::Schema::Ptr& schema) {
723  cid_t cid;
724  if(schema->cid == DB::Schema::NO_CID) {
725  cid = get_next_cid();
726  if(!cid) {
728  return;
729  }
730  } else {
731  cid = schema->cid;
732  }
733 
734  if(schema->col_seq == DB::Types::KeySeq::UNKNOWN ||
735  schema->col_type == DB::Types::Column::UNKNOWN) {
737  return;
738  }
739 
740  Column::create(err, cid);
741  if(err)
742  return;
743 
744  if(DB::Types::is_counter(schema->col_type))
745  schema->cell_versions = 1;
746 
747  auto schema_save = DB::Schema::make(schema);
748  schema_save->cid = cid;
749  if(!schema_save->revision)
750  schema_save->revision = Time::now_ns();
751 
753  err, schema_save, cfg_schema_replication->get());
754  if(!err)
755  Env::Mngr::schemas()->add(err, schema_save);
756 
757  if(!err) {
758  schema = Env::Mngr::schemas()->get(schema_save->cid);
759  } else {
760  Column::remove(err, cid);
761  if(m_last_used_cid >= cid)
762  m_last_used_cid.store(cid - 1);
763  }
764 }
765 
766 void MngdColumns::update(int &err, DB::Schema::Ptr& schema,
767  const DB::Schema::Ptr& old) {
768  if(old->col_seq != schema->col_seq ||
769  DB::Types::is_counter(old->col_type)
770  != DB::Types::is_counter(schema->col_type) ||
771  (schema->cid <= DB::Types::SystemColumn::SYS_CID_END &&
772  !Condition::str_eq(schema->col_name, old->col_name) )) {
774  return;
775  }
776 
777  if(DB::Types::is_counter(schema->col_type))
778  schema->cell_versions = 1;
779 
780  if(schema->cid < DB::Types::SystemColumn::SYS_CID_END) {
781  //different values bad for range-colms
782  schema->cell_versions = 1;
783  schema->cell_ttl = 0;
784  }
785 
786  auto schema_save = DB::Schema::make(schema);
787  if(schema_save->cid == DB::Schema::NO_CID)
788  schema_save->cid = old->cid;
789  if(!schema_save->revision)
790  schema_save->revision = Time::now_ns();
791 
792  if(schema_save->cid == DB::Schema::NO_CID)
794  if(schema_save->equal(old, false))
796  if(err)
797  return;
798 
800  err, schema_save, cfg_schema_replication->get());
801  if(!err) {
802  Env::Mngr::schemas()->replace(schema_save);
803  schema = Env::Mngr::schemas()->get(schema_save->cid);
804  }
805 }
806 
809  const DB::Schema::Ptr& schema, int err,
810  uint64_t req_id) {
813  new Comm::Protocol::Mngr::Req::ColumnUpdate(func, schema, err, req_id)
814  )
815  );
816 }
817 
819  const DB::Schema::Ptr& schema, int err,
820  uint64_t req_id) {
822  SWC_LOG_OSTREAM << "ColumnUpdate ACK Request func=" << int(func)
823  << " req_id=" << req_id;
824  Error::print(SWC_LOG_OSTREAM << ' ', err);
825  schema->print(SWC_LOG_OSTREAM << ' ');
826  );
827 
828  switch(func) {
829  case ColumnMngFunc::INTERNAL_LOAD_ALL: {
830  columns_load();
831  return;
832  }
833  case ColumnMngFunc::INTERNAL_ACK_LOAD:
834  if(err && m_run) {
835  auto existing = Env::Mngr::schemas()->get(schema->cid);
836  if(existing)
838  ColumnMngFunc::INTERNAL_LOAD, existing, Error::OK, req_id, true);
839  }
840  return;
841  case ColumnMngFunc::INTERNAL_ACK_CREATE:
842  case ColumnMngFunc::INTERNAL_ACK_MODIFY:
843  break;
844  case ColumnMngFunc::INTERNAL_ACK_DELETE: {
845  if(!err && !m_schemas_set)
847  if(err)
848  break;
850  if(!m_schemas_set) {
852  } else if(!Env::Mngr::schemas()->get(schema->cid)) {
854  } else if(!m_run) {
856  } else {
857  Column::remove(err, schema->cid);
858  if(!err) {
859  Env::Mngr::schemas()->remove(schema->cid);
860  if(m_last_used_cid >= schema->cid)
861  m_last_used_cid.store(schema->cid - 1);
862  }
863  }
864  break;
865  }
866  default:
867  return;
868  }
869 
870  auto co_func = ColumnMngFunc(uint8_t(func)-1);
871 
872  if(err)
874  SWC_LOG_OSTREAM << "COLUMN-ACK func=" << int(co_func);
875  Error::print(SWC_LOG_OSTREAM << ' ', err);
876  schema->print(SWC_LOG_OSTREAM << ' ');
877  );
878 
879  ColumnReq::Ptr pending = nullptr;
880  {
882  auto it = m_actions_pending.find(req_id);
883  if(it != m_actions_pending.cend()) {
884  pending = std::move(it->second);
885  m_actions_pending.erase(it);
886  }
887  }
888 
889  if(pending) {
890  pending->response(err);
891  } else {
894  << "Missing Pending Req-Ack for func=" << co_func
895  << " req_id=" << req_id;
896  schema->print(SWC_LOG_OSTREAM << ' ');
897  );
898  }
899 }
900 
902  int err;
903  ColumnReq::Ptr req;
904  do {
905  err = Error::OK;
906  req = std::move(m_actions.front());
907 
909  SWC_LOG_OSTREAM << "ColumnMng Request func=" << int(req->function);
910  req->schema->print(SWC_LOG_OSTREAM << ' ');
911  );
912 
913  if(!m_run) {
915 
916  } else if(req->expired(1000)) {
918 
919  } else if(req->schema->col_name.empty()) {
921 
922  } else if(!is_schemas_mngr(err) || err) {
923  if(!err)
925 
926  } else {
929  req->schema->col_name);
930  if(!schema && req->schema->cid != DB::Schema::NO_CID)
931  schema = Env::Mngr::schemas()->get(req->schema->cid);
932 
933  if(!m_schemas_set)
935 
936  if(!err) switch(req->function) {
937  case ColumnMngFunc::CREATE: {
938  if(schema)
939  err = req->schema->cid == schema->cid
942  else
943  create(err, req->schema);
944  break;
945  }
946  case ColumnMngFunc::MODIFY: {
947  if(!schema)
949  else if(req->schema->cid != DB::Schema::NO_CID &&
950  schema->cid != req->schema->cid)
952  else
953  update(err, req->schema, schema);
954  break;
955  }
956  case ColumnMngFunc::REMOVE: {
957  if(!schema)
959  else if(schema->cid != req->schema->cid ||
960  !Condition::str_eq(req->schema->col_name, schema->col_name))
962  else if(schema->cid <= DB::Types::SystemColumn::SYS_CID_END)
964  else
965  req->schema = schema;
966  break;
967  }
968  default:
970  break;
971  }
972  }
973 
974  if(err) {
975  if(err != Error::REQUEST_TIMEOUT)
976  req->response(err);
977 
978  } else {
979  req->id = Time::now_ns();
980  {
982  m_actions_pending[req->id] = req;
984  << "Pending Requests=" << m_actions_pending.size(); );
985  }
986  update_status(req->function, req->schema, Error::OK, req->id, true);
987  }
988 
989  } while(m_actions.pop_and_more());
990 
991 }
992 
993 
994 
995 }} // namespace Manager
996 
SWC::Manager::MngdColumns::initialize
bool initialize()
Definition: MngdColumns.cc:504
SWC::Manager::MngdColumns::require_sync
void require_sync()
Definition: MngdColumns.cc:229
SWC::Manager::MngdColumns::m_actions_pending
std::unordered_map< uint64_t, ColumnReq::Ptr > m_actions_pending
Definition: MngdColumns.h:131
SWC::Manager::Columns::columns_by_fs
static void columns_by_fs(int &err, FS::IdEntries_t &entries)
Definition: Columns.h:28
SWC::DB::Schemas::add
void add(int &err, const Schema::Ptr &schema)
Definition: Schemas.cc:19
SWC::Manager::MngdColumns::is_schemas_mngr
bool is_schemas_mngr(int &err)
Definition: MngdColumns.cc:116
SWC::Core::Semaphore
Definition: Semaphore.h:16
SWC::Config::Property::Value_uint8_g::get
SWC_CAN_INLINE uint8_t get() const noexcept
Definition: Property.h:535
SWC::Manager::MngdColumns::m_last_used_cid
Core::Atomic< cid_t > m_last_used_cid
Definition: MngdColumns.h:126
SWC::Core::StateRunning::stop
constexpr SWC_CAN_INLINE void stop() noexcept
Definition: StateRunning.h:32
SWC::client::Query::Select::Handlers::Common::make
static SWC_CAN_INLINE Ptr make(const Clients::Ptr &clients, Cb_t &&cb=nullptr, bool rsp_partials=false, const Comm::IoContextPtr &io=nullptr, Clients::Flag executor=Clients::DEFAULT)
Definition: Common.h:26
SWC::Core::QueueSafe::push_and_is_1st
SWC_CAN_INLINE bool push_and_is_1st(const ItemT &item)
Definition: QueueSafe.h:54
SWC::Manager::MngdColumns::m_cid_begin
cid_t m_cid_begin
Definition: MngdColumns.h:123
SWC::Manager::MngdColumns::m_columns_load
Core::StateRunning m_columns_load
Definition: MngdColumns.h:116
SWC::Manager::MngdColumns::cfg_delay_cols_init
const Config::Property::Value_int32_g::Ptr cfg_delay_cols_init
Definition: MngdColumns.h:34
SWC::Manager::MngdColumns::get_column
Column::Ptr get_column(int &err, cid_t cid)
Definition: MngdColumns.cc:174
SWC::client::Query::Select::Handlers::Common::Ptr
std::shared_ptr< Common > Ptr
Definition: Common.h:22
SWC::Error::COLUMN_SCHEMA_NAME_NOT_EXISTS
@ COLUMN_SCHEMA_NAME_NOT_EXISTS
Definition: Error.h:105
SWC::System::Resources::concurrency
SWC_CAN_INLINE uint32_t concurrency() const noexcept
Definition: Resources.h:134
SWC_LOG_OSTREAM
#define SWC_LOG_OSTREAM
Definition: Logger.h:44
SWC::Config::Property::Value_uint64_g::get
SWC_CAN_INLINE uint64_t get() const noexcept
Definition: Property.h:648
SWC::Manager::MngdColumns::has_active
bool has_active() noexcept
Definition: MngdColumns.cc:133
SWC::Manager::MngdColumns::m_cid_end
cid_t m_cid_end
Definition: MngdColumns.h:124
SWC::Error::REQUEST_TIMEOUT
@ REQUEST_TIMEOUT
Definition: Error.h:73
SWC::Manager::MngdColumns::ColumnReq::Ptr
std::shared_ptr< ColumnReq > Ptr
Definition: MngdColumns.h:20
SWC::Manager::MngdColumns::set_expect
void set_expect(cid_t cid_begin, cid_t cid_end, uint64_t total, cids_t &&columns, bool initial)
Definition: MngdColumns.cc:249
SWC::Manager::MngdColumns::print
void print(std::ostream &out)
Definition: MngdColumns.cc:500
SWC::Manager::MngdColumns::m_schemas_set
Core::AtomicBool m_schemas_set
Definition: MngdColumns.h:119
SWC::Error::COLUMN_SCHEMA_ID_EMPTY
@ COLUMN_SCHEMA_ID_EMPTY
Definition: Error.h:109
SWC::DB::SchemaPrimitives::NO_CID
static constexpr const cid_t NO_CID
Definition: Schema.h:25
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
MngdColumns.h
SWC_LOGF
#define SWC_LOGF(priority, fmt,...)
Definition: Logger.h:188
SWC::Manager::MngdColumns::is_active
bool is_active(cid_t cid) noexcept
Definition: MngdColumns.cc:139
SWC::DB::Schema::Ptr
std::shared_ptr< Schema > Ptr
Definition: Schema.h:185
SWC::Core::Vector::clear
SWC_CAN_INLINE void clear() noexcept(_NoExceptDestructor)
Definition: Vector.h:120
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
SWC::Manager::MngdColumns::create
void create(int &err, DB::Schema::Ptr &schema)
Definition: MngdColumns.cc:722
SWC::Env::Mngr::post
static SWC_CAN_INLINE void post(T_Handler &&handler)
Definition: MngrEnv.h:39
SWC::Error::COLUMN_SCHEMA_IS_SYSTEM
@ COLUMN_SCHEMA_IS_SYSTEM
Definition: Error.h:113
SWC::Error::COLUMN_SCHEMA_NOT_DIFFERENT
@ COLUMN_SCHEMA_NOT_DIFFERENT
Definition: Error.h:111
SWC::Error::get_text
const char * get_text(const int err) noexcept
Definition: Error.cc:173
SWC::Manager::MngdColumns::change_active
void change_active(const cid_t cid_begin, const cid_t cid_end, bool has_cols)
Definition: MngdColumns.cc:193
SWC::Core::Encoder::Type
Type
Definition: Encoder.h:28
SWC::Common::Files::Schema::load
void load(int &err, const std::string &filepath, DB::Schema::Ptr &schema)
Definition: Schema.h:87
SWC::Manager::MngdColumns::m_mutex_active
Core::MutexSptd m_mutex_active
Definition: MngdColumns.h:121
SWC::LOG_INFO
@ LOG_INFO
Definition: Logger.h:35
SWC::Manager::Schemas::store_create
void store_create(int &err, uint8_t replicas, uint32_t blksz, const DB::Types::Encoder cfg_encoder)
Definition: Schemas.h:26
SWC::Manager::MngdColumns::active
bool active(cid_t &cid_begin, cid_t &cid_end) noexcept
Definition: MngdColumns.cc:146
SWC::Core::MutexSptd::scope
Definition: MutexSptd.h:96
SWC::Env::Mngr::columns
static SWC_CAN_INLINE Manager::Columns * columns() noexcept
Definition: MngrEnv.h:59
SWC::DB::Types::SystemColumn::SYS_CID_END
const cid_t SYS_CID_END
Definition: SystemColumn.h:27
SWC::Manager::Column::remove
static bool remove(int &err, const cid_t cid)
Definition: Column.h:31
SWC::Core::Semaphore::acquire
void acquire()
Definition: Semaphore.cc:29
ColumnUpdate.h
SWC::Manager::Columns::remove
void remove(const cid_t cid)
Definition: Columns.h:156
SWC::Manager::MngdColumns::update_status
void update_status(Comm::Protocol::Mngr::Params::ColumnMng::Function func, const DB::Schema::Ptr &schema, int err, uint64_t req_id, bool initial=false)
Definition: MngdColumns.cc:304
SWC::Manager::Rangers::update
bool update(const Column::Ptr &col, const DB::Schema::Ptr &schema, uint64_t req_id, bool ack_required)
Definition: Rangers.cc:442
SWC::client::Mngr::Group::Ptr
std::shared_ptr< Group > Ptr
Definition: Groups.h:23
SWC::Manager::MngdColumns::m_run
Core::AtomicBool m_run
Definition: MngdColumns.h:114
SWC::Core::Semaphore::available
size_t available()
Definition: Semaphore.cc:19
SWC::Config::Property::Value_int32_g::get
SWC_CAN_INLINE int32_t get() const noexcept
Definition: Property.h:610
SWC::Core::Vector::const_iterator
const value_type * const_iterator
Definition: Vector.h:51
SWC::Error::COLUMN_SCHEMA_NAME_EMPTY
@ COLUMN_SCHEMA_NAME_EMPTY
Definition: Error.h:107
SWC::DB::Types::SystemColumn::is_master
constexpr SWC_CAN_INLINE bool is_master(cid_t cid) noexcept
Definition: SystemColumn.h:31
SWC::Manager::MngdColumns::remove
void remove(const DB::Schema::Ptr &schema, rgrid_t rgrid, uint64_t req_id)
Definition: MngdColumns.cc:407
SWC::Manager::Columns::print
void print(std::ostream &out)
Definition: Columns.h:179
SWC::DB::Cells::Result
Definition: Result.h:16
SWC::Manager::MngdColumns::columns_ready
void columns_ready(int &err)
Definition: MngdColumns.cc:161
SWC::Comm::Protocol::Mngr::Req::ColumnUpdate
Definition: ColumnUpdate.h:15
SWC::DB::Types::MngrRole::SCHEMAS
const uint8_t SCHEMAS
Definition: MngrRole.h:15
SWC::Condition::str_eq
bool str_eq(const char *s1, const char *s2) noexcept SWC_ATTRIBS((SWC_ATTRIB_O3))
Definition: Comparators_basic.h:237
SWC::Core::QueueSafe::front
SWC_CAN_INLINE ItemT & front() noexcept
Definition: QueueSafe.h:72
SWC::Core::Semaphore::wait_all
void wait_all()
Definition: Semaphore.cc:62
SWC::DB::Types::SystemColumn::get_range_type
constexpr SWC_CAN_INLINE Range get_range_type(cid_t cid) noexcept
Definition: SystemColumn.h:51
SWC::Core::QueueSafe::empty
SWC_CAN_INLINE bool empty() noexcept
Definition: QueueSafe.h:78
SWC::Core::Atomic::add_rslt
constexpr SWC_CAN_INLINE T add_rslt(T v) noexcept
Definition: Atomic.h:120
SWC::Manager::MngdColumns::m_expected_load
std::forward_list< cid_t > m_expected_load
Definition: MngdColumns.h:127
SWC::Core::AtomicBase::store
constexpr SWC_CAN_INLINE void store(T v) noexcept
Definition: Atomic.h:37
SWC::Error::OK
@ OK
Definition: Error.h:45
Scanner.h
SWC::Core::Vector::empty
constexpr SWC_CAN_INLINE bool empty() const noexcept
Definition: Vector.h:168
SWC::Core::QueueSafe::pop_and_more
SWC_CAN_INLINE bool pop_and_more()
Definition: QueueSafe.h:90
SWC_CAN_INLINE
#define SWC_CAN_INLINE
Definition: Compat.h:102
SWC::LOG_DEBUG
@ LOG_DEBUG
Definition: Logger.h:36
SWC::DB::Schemas::get
Schema::Ptr get(cid_t cid) noexcept
Definition: Schemas.cc:56
SWC::Condition::FIP
@ FIP
Definition: Comparators.h:75
SWC::DB::Cell::Serial::Value::UNKNOWN
@ UNKNOWN
Definition: CellValueSerialField.h:34
SWC_LOG
#define SWC_LOG(priority, message)
Definition: Logger.h:191
SWC::DB::Schemas::all
void all(SchemasVec &entries)
Definition: Schemas.cc:79
SWC::Core::Vector::end
constexpr SWC_CAN_INLINE iterator end() noexcept
Definition: Vector.h:227
SWC::Manager::MngdColumns::m_cid_active
bool m_cid_active
Definition: MngdColumns.h:122
SWC::Manager::MngdColumns::cfg_schema_replication
const Config::Property::Value_uint8_g::Ptr cfg_schema_replication
Definition: MngdColumns.h:30
SWC::Manager::MngdColumns::get_next_cid
cid_t get_next_cid()
Definition: MngdColumns.cc:708
SWC
The SWC-DB C++ namespace 'SWC'.
Definition: main.cc:12
SWC::DB::Schemas::remove
void remove(cid_t cid)
Definition: Schemas.cc:34
SWC::Error::MNGR_NOT_INITIALIZED
@ MNGR_NOT_INITIALIZED
Definition: Error.h:88
SWC::Manager::MngdColumns::cfg_schemas_store_encoder
const Config::Property::Value_enum_g::Ptr cfg_schemas_store_encoder
Definition: MngdColumns.h:33
SWC::Manager::Columns::is_an_initialization
bool is_an_initialization(int &err, const DB::Schema::Ptr &schema)
Definition: Columns.h:54
SWC::DB::Schemas::replace
void replace(const Schema::Ptr &schema)
Definition: Schemas.cc:45
SWC::Manager::MngdColumns::cfg_schemas_store_blksz
const Config::Property::Value_int32_g::Ptr cfg_schemas_store_blksz
Definition: MngdColumns.h:32
SWC::DB::Schema::make
static SWC_CAN_INLINE Ptr make()
Definition: Schema.h:189
SWC::DB::Types::is_counter
bool SWC_CONST_FUNC is_counter(const Column typ) noexcept
Definition: Column.cc:26
SWC::Manager::MngdColumns::m_expected_remain
uint64_t m_expected_remain
Definition: MngdColumns.h:125
size
uint32_t size
Buffer size.
Definition: HeaderBufferInfo.h:47
SWC::Condition::EQ
@ EQ
Definition: Comparators.h:32
SWC::Manager::MngdColumns::reset
void reset(bool schemas_mngr)
Definition: MngdColumns.cc:98
SWC::Manager::ColumnMngFunc
Comm::Protocol::Mngr::Params::ColumnMng::Function ColumnMngFunc
Definition: MngdColumns.cc:19
SWC::Error::COLUMN_NOT_READY
@ COLUMN_NOT_READY
Definition: Error.h:99
SWC::Manager::MngrRole::is_active_role
bool is_active_role(uint8_t role)
Definition: MngrRole.cc:80
SWC::Env::Mngr::res
static SWC_CAN_INLINE System::Resources & res() noexcept
Definition: MngrEnv.h:49
SWC::Comm::Resolver::sort
void sort(const Networks &nets, const EndPoints &endpoints, EndPoints &sorted)
Definition: Resolver.cc:243
SWC::Core::StateRunning::running
constexpr SWC_CAN_INLINE bool running() noexcept
Definition: StateRunning.h:37
SWC::rgrid_t
uint64_t rgrid_t
Definition: Identifiers.h:18
SWC::DB::Types::SystemColumn::get_sys_cid
uint8_t SWC_CONST_FUNC get_sys_cid(KeySeq col_seq, Range col_type) noexcept
Definition: SystemColumn.cc:71
SWC::DB::Types::SystemColumn::SYS_RGR_DATA
const cid_t SYS_RGR_DATA
Definition: SystemColumn.h:22
SWC::Manager::Rangers::sync
void sync()
Definition: Rangers.cc:277
SWC::Error::COLUMN_CHANGE_INCOMPATIBLE
@ COLUMN_CHANGE_INCOMPATIBLE
Definition: Error.h:114
SWC::LOG_ERROR
@ LOG_ERROR
Definition: Logger.h:32
SWC::Comm::Protocol::Mngr::Params::ColumnMng::Function
Function
Definition: ColumnMng.h:21
SWC::Error::COLUMN_SCHEMA_NAME_NOT_CORRES
@ COLUMN_SCHEMA_NAME_NOT_CORRES
Definition: Error.h:108
SWC_FMT_LU
#define SWC_FMT_LU
Definition: Compat.h:98
Semaphore.h
SWC::DB::Schemas::reset
void reset()
Definition: Schemas.cc:305
SWC::cid_t
uint64_t cid_t
Definition: Identifiers.h:16
SWC::Error::COLUMN_NOT_EXISTS
@ COLUMN_NOT_EXISTS
Definition: Error.h:100
SWC::Core::Vector< cid_t, cid_t >
SWC::Manager::MngdColumns::create_schemas_store
void create_schemas_store()
Definition: MngdColumns.cc:80
SWC::Manager::Rangers::schedule_check
void schedule_check(uint32_t t_ms=10000)
Definition: Rangers.cc:90
SWC::Manager::MngdColumns::update
void update(Comm::Protocol::Mngr::Params::ColumnMng::Function func, const DB::Schema::Ptr &schema, int err, uint64_t req_id)
Definition: MngdColumns.cc:808
SWC::Manager::Columns::get_column
Column::Ptr get_column(int &err, const cid_t cid)
Definition: Columns.h:71
RangeUnload.cc
SWC::DB::Specs::Interval
Definition: SpecsInterval.h:25
Committer.h
SWC::Common::Files::Schema::save_with_validation
void save_with_validation(int &err, const DB::Schema::Ptr &schema_save, uint8_t replication)
Definition: Schema.h:174
SWC::Manager::MngdColumns::m_mutex_actions
Core::MutexSptd m_mutex_actions
Definition: MngdColumns.h:129
SWC::Env::Mngr::schemas
static SWC_CAN_INLINE Manager::Schemas * schemas() noexcept
Definition: MngrEnv.h:54
SWC::Error::COLUMN_SCHEMA_NAME_EXISTS
@ COLUMN_SCHEMA_NAME_EXISTS
Definition: Error.h:104
SWC::Manager::MngdColumns
Definition: MngdColumns.h:15
SWC::Manager::MngdColumns::STATE_COLUMNS_NOT_INITIALIZED
constexpr static uint64_t STATE_COLUMNS_NOT_INITIALIZED
Definition: MngdColumns.h:133
SWC::Manager::Rangers::assign_ranges
void assign_ranges()
Definition: Rangers.cc:544
SWC::Core::Vector::cend
constexpr SWC_CAN_INLINE const_iterator cend() const noexcept
Definition: Vector.h:232
SWC::Manager::MngdColumns::cfg_schemas_store_cap
const Config::Property::Value_uint64_g::Ptr cfg_schemas_store_cap
Definition: MngdColumns.h:31
SWC::Error::NOT_IMPLEMENTED
@ NOT_IMPLEMENTED
Definition: Error.h:74
SWC::Core::QueueSafe::size
SWC_CAN_INLINE size_t size() noexcept
Definition: QueueSafe.h:84
SWC::Manager::MngdColumns::stop
void stop()
Definition: MngdColumns.cc:48
SWC::Manager::MngdColumns::expected_ready
bool expected_ready() noexcept
Definition: MngdColumns.cc:156
SWC::Manager::MngdColumns::run_actions
void run_actions()
Definition: MngdColumns.cc:901
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::Env::Mngr::role
static SWC_CAN_INLINE Manager::MngrRole * role() noexcept
Definition: MngrEnv.h:64
SWC::Manager::Columns::reset
void reset()
Definition: Columns.h:39
SWC::Manager::MngrRole::req_mngr_inchain
void req_mngr_inchain(const Comm::client::ConnQueue::ReqBase::Ptr &req)
Definition: MngrRole.cc:137
SWC::Manager::MngdColumns::columns_load
bool columns_load()
Definition: MngdColumns.cc:605
SWC::Manager::Rangers::wait_health_check
void wait_health_check(cid_t cid=DB::Schema::NO_CID)
Definition: Rangers.cc:521
SWC::Manager::MngdColumns::MngdColumns
MngdColumns()
Definition: MngdColumns.cc:22
SWC::LOG_WARN
@ LOG_WARN
Definition: Logger.h:33
SWC::Manager::MngdColumns::m_mutex_schemas
Core::MutexSptd m_mutex_schemas
Definition: MngdColumns.h:118
SWC::Manager::Columns::state
void state(int &err)
Definition: Columns.h:48
SWC::Core::Semaphore::release
void release()
Definition: Semaphore.cc:36
ColumnsUnload.cc
SWC::Manager::Column::Ptr
std::shared_ptr< Column > Ptr
Definition: Column.h:24
SWC::Manager::Column::create
static bool create(int &err, const cid_t cid)
Definition: Column.h:26
SWC::Error::MNGR_NOT_ACTIVE
@ MNGR_NOT_ACTIVE
Definition: Error.h:87
SWC::Env::Mngr::io
static SWC_CAN_INLINE Comm::IoContextPtr io() noexcept
Definition: MngrEnv.h:33
SWC::Manager::Rangers::column_delete
void column_delete(const DB::Schema::Ptr &schema, uint64_t req_id, const Core::Vector< rgrid_t > &rgrids)
Definition: Rangers.cc:467
SWC::DB::Types::Column::SERIAL
@ SERIAL
SWC::Error::COLUMN_SCHEMA_ID_EXISTS
@ COLUMN_SCHEMA_ID_EXISTS
Definition: Error.h:110
SWC::Core::Vector::push_back
SWC_CAN_INLINE void push_back(ArgsT &&... args)
Definition: Vector.h:331
SWC::Error::print
void print(std::ostream &out, int err)
Definition: Error.cc:191
SWC_FMT_LD
#define SWC_FMT_LD
Definition: Compat.h:99
SWC::Core::Vector::cbegin
constexpr SWC_CAN_INLINE const_iterator cbegin() const noexcept
Definition: Vector.h:216
SWC::Manager::MngdColumns::m_actions
Core::QueueSafe< ColumnReq::Ptr > m_actions
Definition: MngdColumns.h:130
SWC::Core::to_string
SWC_CAN_INLINE std::string to_string(const BitFieldInt< T, SZ > &v)
Definition: BitFieldInt.h:263
Common.h
SWC::Error::INVALID_ARGUMENT
@ INVALID_ARGUMENT
Definition: Error.h:58
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_LOG_CURRENT_EXCEPTION
#define SWC_LOG_CURRENT_EXCEPTION(_s_)
Definition: Exception.h:144
Common.h
SWC::Comm::Protocol::Mngr::Req::ColumnUpdate::Ptr
std::shared_ptr< ColumnUpdate > Ptr
Definition: ColumnUpdate.h:17
SWC::DB::Types::MngrRole::COLUMNS
const uint8_t COLUMNS
Definition: MngrRole.h:14
SWC::Error::COLUMN_REACHED_ID_LIMIT
@ COLUMN_REACHED_ID_LIMIT
Definition: Error.h:101
SWC::Env::Mngr::rangers
static SWC_CAN_INLINE Manager::Rangers * rangers() noexcept
Definition: MngrEnv.h:69
SWC::Core::Vector::reserve
SWC_CAN_INLINE void reserve(size_type cap)
Definition: Vector.h:288
SWC::Config::Property::Value_enum_g::get
SWC_CAN_INLINE int32_t get() const noexcept
Definition: Property.h:692
SWC::Manager::MngdColumns::update_status_ack
void update_status_ack(Comm::Protocol::Mngr::Params::ColumnMng::Function func, const DB::Schema::Ptr &schema, int err, uint64_t req_id)
Definition: MngdColumns.cc:818
SWC::Manager::MngdColumns::action
void action(const ColumnReq::Ptr &req)
Definition: MngdColumns.cc:238
SWC::Core::Vector::begin
constexpr SWC_CAN_INLINE iterator begin() noexcept
Definition: Vector.h:211