mirror of
https://github.com/scylladb/scylladb.git
synced 2026-05-13 03:12:13 +00:00
868d057aae
Since both are bucket+prefix oriented, we can basically use same options for both, only distinguished by actual protocol. Abstract the types and the helper parse etc routines to handle either. Use "gs" as term for gcs (google compute storage), since this is the URL scheme used.
630 lines
21 KiB
C++
630 lines
21 KiB
C++
/*
|
||
* Copyright (C) 2021-present ScyllaDB
|
||
*/
|
||
|
||
/*
|
||
* SPDX-License-Identifier: LicenseRef-ScyllaDB-Source-Available-1.0
|
||
*/
|
||
|
||
#include <ranges>
|
||
#include "data_dictionary.hh"
|
||
#include "cql3/description.hh"
|
||
#include "impl.hh"
|
||
#include "user_types_metadata.hh"
|
||
#include "keyspace_metadata.hh"
|
||
#include "schema/schema.hh"
|
||
#include "cql3/util.hh"
|
||
#include "gms/feature_service.hh"
|
||
#include <fmt/core.h>
|
||
#include <fmt/ranges.h>
|
||
#include <fmt/std.h>
|
||
#include <ios>
|
||
#include <ostream>
|
||
#include <array>
|
||
#include "replica/database.hh"
|
||
#include "utils/overloaded_functor.hh"
|
||
|
||
namespace data_dictionary {
|
||
|
||
schema_ptr
|
||
table::schema() const {
|
||
return _ops->get_table_schema(*this);
|
||
}
|
||
|
||
const std::vector<view_ptr>&
|
||
table::views() const {
|
||
return _ops->get_table_views(*this);
|
||
}
|
||
|
||
const secondary_index::secondary_index_manager&
|
||
table::get_index_manager() const {
|
||
return _ops->get_index_manager(*this);
|
||
}
|
||
|
||
lw_shared_ptr<keyspace_metadata>
|
||
keyspace::metadata() const {
|
||
return _ops->get_keyspace_metadata(*this);
|
||
}
|
||
|
||
const user_types_metadata&
|
||
keyspace::user_types() const {
|
||
return metadata()->user_types();
|
||
}
|
||
|
||
bool
|
||
keyspace::is_internal() const {
|
||
return _ops->is_internal(*this);
|
||
}
|
||
|
||
bool
|
||
keyspace::uses_tablets() const {
|
||
return metadata()->uses_tablets();
|
||
}
|
||
|
||
const locator::abstract_replication_strategy&
|
||
keyspace::get_replication_strategy() const {
|
||
return _ops->get_replication_strategy(*this);
|
||
}
|
||
|
||
const table_schema_version&
|
||
database::get_version() const {
|
||
return _ops->get_version(*this);
|
||
}
|
||
|
||
std::optional<keyspace>
|
||
database::try_find_keyspace(std::string_view name) const {
|
||
return _ops->try_find_keyspace(*this, name);
|
||
}
|
||
|
||
bool
|
||
database::has_keyspace(std::string_view name) const {
|
||
return bool(try_find_keyspace(name));
|
||
}
|
||
|
||
keyspace
|
||
database::find_keyspace(std::string_view name) const {
|
||
auto ks = try_find_keyspace(name);
|
||
if (!ks) {
|
||
throw no_such_keyspace(name);
|
||
}
|
||
return *ks;
|
||
}
|
||
|
||
std::vector<keyspace>
|
||
database::get_keyspaces() const {
|
||
return _ops->get_keyspaces(*this);
|
||
}
|
||
|
||
std::vector<sstring>
|
||
database::get_user_keyspaces() const {
|
||
return _ops->get_user_keyspaces(*this);
|
||
}
|
||
|
||
std::vector<sstring>
|
||
database::get_all_keyspaces() const {
|
||
return _ops->get_all_keyspaces(*this);
|
||
}
|
||
|
||
std::vector<table>
|
||
database::get_tables() const {
|
||
return _ops->get_tables(*this);
|
||
}
|
||
|
||
std::optional<table>
|
||
database::try_find_table(std::string_view ks, std::string_view table) const {
|
||
return _ops->try_find_table(*this, ks, table);
|
||
}
|
||
|
||
table
|
||
database::find_table(std::string_view ks, std::string_view table) const {
|
||
auto t = try_find_table(ks, table);
|
||
if (!t) {
|
||
throw no_such_column_family(ks, table);
|
||
}
|
||
return *t;
|
||
}
|
||
|
||
std::optional<table>
|
||
database::try_find_table(table_id id) const {
|
||
return _ops->try_find_table(*this, id);
|
||
}
|
||
|
||
table
|
||
database::find_column_family(table_id uuid) const {
|
||
auto t = try_find_table(uuid);
|
||
if (!t) {
|
||
throw no_such_column_family(uuid);
|
||
}
|
||
return *t;
|
||
}
|
||
|
||
schema_ptr
|
||
database::find_schema(std::string_view ks, std::string_view table) const {
|
||
return find_table(ks, table).schema();
|
||
}
|
||
|
||
schema_ptr
|
||
database::find_schema(table_id uuid) const {
|
||
return find_column_family(uuid).schema();
|
||
}
|
||
|
||
bool
|
||
database::has_schema(std::string_view ks_name, std::string_view cf_name) const {
|
||
return bool(try_find_table(ks_name, cf_name));
|
||
}
|
||
|
||
table
|
||
database::find_column_family(schema_ptr s) const {
|
||
return find_column_family(s->id());
|
||
}
|
||
|
||
schema_ptr
|
||
database::find_indexed_table(std::string_view ks_name, std::string_view index_name) const {
|
||
return _ops->find_indexed_table(*this, ks_name, index_name);
|
||
}
|
||
|
||
sstring
|
||
database::get_available_index_name(std::string_view ks_name, std::string_view table_name,
|
||
std::optional<sstring> index_name_root) const {
|
||
return _ops->get_available_index_name(*this, ks_name, table_name, index_name_root);
|
||
}
|
||
|
||
std::set<sstring>
|
||
database::existing_index_names(std::string_view ks_name, std::string_view cf_to_exclude) const {
|
||
return _ops->existing_index_names(*this, ks_name, cf_to_exclude);
|
||
}
|
||
|
||
schema_ptr
|
||
database::get_cdc_base_table(std::string_view ks_name, std::string_view table_name) const {
|
||
return get_cdc_base_table(*find_table(ks_name, table_name).schema());
|
||
}
|
||
|
||
schema_ptr
|
||
database::get_cdc_base_table(const schema& s) const {
|
||
return _ops->get_cdc_base_table(*this, s);
|
||
}
|
||
|
||
const db::extensions&
|
||
database::extensions() const {
|
||
return _ops->get_extensions(*this);
|
||
}
|
||
|
||
const gms::feature_service&
|
||
database::features() const {
|
||
return _ops->get_features(*this);
|
||
}
|
||
|
||
const db::config&
|
||
database::get_config() const {
|
||
return _ops->get_config(*this);
|
||
}
|
||
|
||
replica::database&
|
||
database::real_database() const {
|
||
return _ops->real_database(*this);
|
||
}
|
||
|
||
replica::database* database::real_database_ptr() const {
|
||
return _ops->real_database_ptr(*this);
|
||
}
|
||
|
||
impl::~impl() = default;
|
||
|
||
keyspace_metadata::keyspace_metadata(std::string_view name,
|
||
std::string_view strategy_name,
|
||
locator::replication_strategy_config_options strategy_options,
|
||
std::optional<unsigned> initial_tablets,
|
||
bool durable_writes,
|
||
std::vector<schema_ptr> cf_defs,
|
||
user_types_metadata user_types,
|
||
storage_options storage_opts)
|
||
: _name{name}
|
||
, _strategy_name{locator::abstract_replication_strategy::to_qualified_class_name(strategy_name.empty() ? "NetworkTopologyStrategy" : strategy_name)}
|
||
, _strategy_options{std::move(strategy_options)}
|
||
, _initial_tablets(initial_tablets)
|
||
, _durable_writes{durable_writes}
|
||
, _user_types{std::move(user_types)}
|
||
, _storage_options(make_lw_shared<storage_options>(std::move(storage_opts)))
|
||
{
|
||
for (auto&& s : cf_defs) {
|
||
_cf_meta_data.emplace(s->cf_name(), s);
|
||
}
|
||
}
|
||
|
||
void keyspace_metadata::validate(const gms::feature_service& fs, const locator::topology& topology) const {
|
||
using namespace locator;
|
||
locator::replication_strategy_params params(strategy_options(), initial_tablets());
|
||
auto strategy = locator::abstract_replication_strategy::create_replication_strategy(strategy_name(), params, topology);
|
||
strategy->validate_options(fs, topology);
|
||
}
|
||
|
||
lw_shared_ptr<keyspace_metadata>
|
||
keyspace_metadata::new_keyspace(std::string_view name,
|
||
std::string_view strategy_name,
|
||
locator::replication_strategy_config_options options,
|
||
std::optional<unsigned> initial_tablets,
|
||
bool durables_writes,
|
||
storage_options storage_opts,
|
||
std::vector<schema_ptr> cf_defs)
|
||
{
|
||
return ::make_lw_shared<keyspace_metadata>(name, strategy_name, options, initial_tablets, durables_writes, cf_defs, user_types_metadata{}, storage_opts);
|
||
}
|
||
|
||
lw_shared_ptr<keyspace_metadata>
|
||
keyspace_metadata::new_keyspace(const keyspace_metadata& ksm) {
|
||
return new_keyspace(ksm.name(), ksm.strategy_name(), ksm.strategy_options(), ksm.initial_tablets(), ksm.durable_writes(), ksm.get_storage_options());
|
||
}
|
||
|
||
void keyspace_metadata::add_user_type(const user_type ut) {
|
||
_user_types.add_type(ut);
|
||
}
|
||
|
||
void keyspace_metadata::remove_user_type(const user_type ut) {
|
||
_user_types.remove_type(ut);
|
||
}
|
||
|
||
std::vector<schema_ptr> keyspace_metadata::tables() const {
|
||
return _cf_meta_data
|
||
| std::views::values
|
||
| std::views::filter([] (const auto& s) { return !s->is_view(); })
|
||
| std::ranges::to<std::vector<schema_ptr>>();
|
||
}
|
||
|
||
std::vector<view_ptr> keyspace_metadata::views() const {
|
||
return _cf_meta_data
|
||
| std::views::values
|
||
| std::views::filter([] (const auto& s) { return s->is_view(); })
|
||
| std::views::transform([] (auto& s) { return view_ptr(s); })
|
||
| std::ranges::to<std::vector<view_ptr>>();
|
||
}
|
||
|
||
static storage_options::local local_from_map(const std::map<sstring, sstring>& values) {
|
||
if (!values.empty()) {
|
||
throw std::runtime_error("Local storage does not accept any custom options");
|
||
}
|
||
return {};
|
||
}
|
||
|
||
std::map<sstring, sstring> storage_options::local::to_map() const {
|
||
return {};
|
||
}
|
||
|
||
std::string_view storage_options::local::name() const {
|
||
return LOCAL_NAME;
|
||
}
|
||
|
||
static storage_options::object_storage object_storage_from_map(std::string_view type, const std::map<sstring, sstring>& values) {
|
||
storage_options::object_storage options;
|
||
const std::array<std::pair<sstring, std::string*>, 2> allowed_options {
|
||
std::make_pair("bucket", &options.bucket),
|
||
std::make_pair("endpoint", &options.endpoint),
|
||
};
|
||
for (auto& option : allowed_options) {
|
||
if (auto it = values.find(option.first); it != values.end()) {
|
||
*option.second = it->second;
|
||
} else {
|
||
throw std::runtime_error(fmt::format("Missing {} option: {}", type, option.first));
|
||
}
|
||
}
|
||
if (values.size() > allowed_options.size()) {
|
||
throw std::runtime_error(fmt::format("Extraneous options for {}: {}; allowed: {}",
|
||
fmt::join(values | std::views::keys, ","), type,
|
||
fmt::join(allowed_options | std::views::keys, ",")));
|
||
}
|
||
options.type = std::string(type);
|
||
return options;
|
||
}
|
||
|
||
std::map<sstring, sstring> storage_options::object_storage::to_map() const {
|
||
return {{"bucket", bucket},
|
||
{"endpoint", endpoint}};
|
||
}
|
||
|
||
std::string_view storage_options::object_storage::name() const {
|
||
return type;
|
||
}
|
||
|
||
bool storage_options::object_storage::operator==(const object_storage&) const = default;
|
||
|
||
bool storage_options::is_local_type() const noexcept {
|
||
return std::holds_alternative<local>(value);
|
||
}
|
||
|
||
bool storage_options::is_object_storage_type() const noexcept {
|
||
return std::holds_alternative<object_storage>(value);
|
||
}
|
||
|
||
bool storage_options::is_s3_type() const noexcept {
|
||
return is_object_storage_type() && type_string() == S3_NAME;
|
||
}
|
||
|
||
bool storage_options::is_gs_type() const noexcept {
|
||
return is_object_storage_type() && type_string() == GS_NAME;
|
||
}
|
||
|
||
const std::string storage_options::LOCAL_NAME = "LOCAL";
|
||
const std::string storage_options::S3_NAME = "S3";
|
||
const std::string storage_options::GS_NAME = "GS";
|
||
|
||
storage_options::value_type storage_options::from_map(std::string_view type, const std::map<sstring, sstring>& values) {
|
||
if (type == LOCAL_NAME) {
|
||
return local_from_map(values);
|
||
}
|
||
if (type == S3_NAME || type == GS_NAME) {
|
||
return object_storage_from_map(type, values);
|
||
}
|
||
throw std::runtime_error(fmt::format("Unknown storage type: {}", type));
|
||
}
|
||
|
||
std::string_view storage_options::type_string() const {
|
||
return std::visit([] (auto& opt) { return opt.name(); }, value);
|
||
}
|
||
|
||
std::map<sstring, sstring> storage_options::to_map() const {
|
||
return std::visit([] (auto& opt) { return opt.to_map(); }, value);
|
||
}
|
||
|
||
bool storage_options::can_update_to(const storage_options& new_options) {
|
||
return value == new_options.value;
|
||
}
|
||
|
||
storage_options storage_options::append_to_object_storage_prefix(const sstring& s) const {
|
||
// when restoring from object storage, the API of /storage_service/restore
|
||
// provides:
|
||
// 1. a shared prefix
|
||
// 2. a list of sstables, each of which has its own partial path
|
||
//
|
||
// for example, assuming we have following API call:
|
||
// - shared prefix: /bucket/ks/cf
|
||
// - sstables
|
||
// - 3123/me-3gdq_0bki_2cvk01yl83nj0tp5gh-big-TOC.txt
|
||
// - 3123/me-3gdq_0bki_2edkg2vx4xtksugjj5-big-TOC.txt
|
||
// - 3245/me-3gdq_0bki_2cvk02wubgncy8qd41-big-TOC.txt
|
||
//
|
||
// note, this example shows three sstables from two different snapshot backups.
|
||
//
|
||
// we assume all sstables' locations share the same base prefix (storage_options::object_storage::prefix).
|
||
// however, sstable in different backups have different prefixes. to handle this, we compose
|
||
// a per-sstable prefix by concatenating the shared prefix and the "parent directory" of the
|
||
// sstable's location. the resulting structure looks like:
|
||
//
|
||
// sstables:
|
||
// - prefix: /bucket/ks/cf/3123
|
||
// desc: me-3gdq_0bki_2cvk01yl83nj0tp5gh-big
|
||
// - prefix: /bucket/ks/cf/3123
|
||
// desc: me-3gdq_0bki_2edkg2vx4xtksugjj5-big
|
||
// - prefix: /bucket/ks/cf/3145
|
||
// desc: me-3gdq_0bki_2cvk02wubgncy8qd41-big
|
||
SCYLLA_ASSERT(!is_local_type());
|
||
storage_options ret = *this;
|
||
if (s.empty()) {
|
||
// scylla-manager should always pass sstables with non-empty dirname,
|
||
// but still..
|
||
return ret;
|
||
}
|
||
|
||
object_storage options = std::get<object_storage>(value);
|
||
SCYLLA_ASSERT(std::holds_alternative<sstring>(options.location));
|
||
sstring prefix = std::get<sstring>(options.location);
|
||
options.location = seastar::format("{}/{}", prefix, s);
|
||
ret.value = std::move(options);
|
||
return ret;
|
||
}
|
||
|
||
storage_options make_local_options(std::filesystem::path dir) {
|
||
storage_options so;
|
||
so.value = data_dictionary::storage_options::local { .dir = std::move(dir) };
|
||
return so;
|
||
}
|
||
|
||
static std::string fqn_type(const std::string& fqn) {
|
||
auto i = fqn.find_first_of(':');
|
||
return fqn.substr(0, i) | std::views::transform(&toupper) | std::ranges::to<std::string>();
|
||
}
|
||
|
||
storage_options make_object_storage_options(const std::string& endpoint, const std::string& fqn, abort_source* as) {
|
||
std::string bucket;
|
||
std::string object;
|
||
auto type = fqn_type(fqn);
|
||
object_storage_fqn_to_parts(fqn, type, bucket, object);
|
||
object = std::filesystem::path(object).parent_path().string(); // remove the filename and trailing separator from the path
|
||
return make_object_storage_options(endpoint, type, bucket, object, as);
|
||
}
|
||
|
||
storage_options make_object_storage_options(const std::string& endpoint, const std::string& type, const std::string& bucket, const std::string& prefix, abort_source* as) {
|
||
storage_options so;
|
||
storage_options::object_storage os{
|
||
.bucket = std::move(bucket), .endpoint = endpoint, .location = std::move(prefix),
|
||
.abort_source = as,
|
||
.type = type | std::views::transform(&toupper) | std::ranges::to<std::string>()
|
||
};
|
||
so.value = std::move(os);
|
||
return so;
|
||
}
|
||
|
||
namespace fs = std::filesystem;
|
||
using namespace std::string_literals;
|
||
|
||
static fs::path object_store_canonicalize(const fs::path& path, std::string_view type) {
|
||
if (!is_object_storage_fqn(path, type) || path.string().length() < (type.length() + 2)) {
|
||
return path;
|
||
}
|
||
// Canonicalizing the original "<type>://" changes it to "<type>:/". Trim and re-add the "type://" prefix.
|
||
auto canonical = path.lexically_normal().string().substr(type.length() + 2);
|
||
return (type | std::views::transform(&tolower) | std::ranges::to<std::string>()) + "://"s + canonical;
|
||
}
|
||
|
||
bool is_object_storage_fqn(const fs::path& fqn, std::string_view type) {
|
||
if (fqn.empty()) {
|
||
return false;
|
||
}
|
||
std::string tmp = *(fqn.begin());
|
||
return tmp.size() == (type.size() + 1) // additional ':'
|
||
&& tmp.back() == ':'
|
||
// allow case insensitive checks, like type=S3 as well as type=s3. Only because ::name
|
||
// members (history) are upper case.
|
||
&& std::equal(tmp.begin(), tmp.begin() + type.size(), type.begin(), [](char c1, char c2) {
|
||
return ::tolower(c1) == ::tolower(c2);
|
||
})
|
||
;
|
||
}
|
||
|
||
bool object_storage_fqn_to_parts(const fs::path& fqn, std::string_view type, std::string& bucket_name, std::string& object_name) {
|
||
if (!is_object_storage_fqn(fqn, type)) {
|
||
return false;
|
||
}
|
||
|
||
const auto canonical = object_store_canonicalize(fqn, type);
|
||
auto it = canonical.begin();
|
||
|
||
// Expect at least two components: the scheme (e.g., "s3:") and the bucket name.
|
||
if (std::distance(it, canonical.end()) < 2) {
|
||
return false;
|
||
}
|
||
|
||
// Skip the scheme component.
|
||
++it;
|
||
|
||
// The next component is the bucket name.
|
||
bucket_name = it->string();
|
||
|
||
// Advance to check for object parts.
|
||
++it;
|
||
if (it == canonical.end()) {
|
||
// No object parts – default to root.
|
||
object_name = "/";
|
||
return true;
|
||
}
|
||
|
||
// Combine remaining parts into the object path.
|
||
fs::path obj;
|
||
for (; it != canonical.end(); ++it) {
|
||
obj /= *it;
|
||
}
|
||
|
||
object_name = obj.string().empty() ? "/" : obj.string();
|
||
return true;
|
||
}
|
||
|
||
no_such_keyspace::no_such_keyspace(std::string_view ks_name)
|
||
: runtime_error{fmt::format("Can't find a keyspace {}", ks_name)}
|
||
{
|
||
}
|
||
|
||
no_such_column_family::no_such_column_family(const table_id& uuid)
|
||
: runtime_error{fmt::format("Can't find a column family with UUID {}", uuid)}
|
||
{
|
||
}
|
||
|
||
no_such_column_family::no_such_column_family(std::string_view ks_name, std::string_view cf_name)
|
||
: runtime_error{fmt::format("Can't find a column family {} in keyspace {}", cf_name, ks_name)}
|
||
{
|
||
}
|
||
|
||
no_such_column_family::no_such_column_family(std::string_view ks_name, const table_id& uuid)
|
||
: runtime_error{fmt::format("Can't find a column family with UUID {} in keyspace {}", uuid, ks_name)}
|
||
{
|
||
}
|
||
|
||
cql3::description keyspace_metadata::describe(const replica::database& db, cql3::with_create_statement with_create_statement) const {
|
||
auto maybe_create_statement = std::invoke([&] -> std::optional<managed_string> {
|
||
if (!with_create_statement) {
|
||
return std::nullopt;
|
||
}
|
||
|
||
fragmented_ostringstream os;
|
||
|
||
os << "CREATE KEYSPACE " << cql3::util::maybe_quote(_name)
|
||
<< " WITH replication = {'class': " << cql3::util::single_quote(_strategy_name);
|
||
for (const auto& opt: _strategy_options) {
|
||
os << ", " << cql3::util::single_quote(opt.first) << ": ";
|
||
std::visit(overloaded_functor{
|
||
[&os] (const sstring& str) {
|
||
os << cql3::util::single_quote(str);
|
||
},
|
||
[&os] (const std::vector<sstring>& vec) {
|
||
os << "[";
|
||
for (auto it = vec.begin(); it != vec.end(); ++it) {
|
||
if (it != vec.begin()) {
|
||
os << ", ";
|
||
}
|
||
os << cql3::util::single_quote(*it);
|
||
}
|
||
os << "]";
|
||
}
|
||
}, opt.second);
|
||
}
|
||
if (!_storage_options->is_local_type()) {
|
||
os << "} AND storage = {'type': " << cql3::util::single_quote(sstring(_storage_options->type_string()));
|
||
for (const auto& e : _storage_options->to_map()) {
|
||
os << ", " << cql3::util::single_quote(e.first) << ": " << cql3::util::single_quote(e.second);
|
||
}
|
||
}
|
||
os << "} AND durable_writes = " << fmt::to_string(_durable_writes);
|
||
if (db.features().tablets) {
|
||
if (!_initial_tablets.has_value()) {
|
||
os << " AND tablets = {'enabled': false}";
|
||
} else {
|
||
os << format(" AND tablets = {{'enabled': true{}}}", _initial_tablets.value() ? format(", 'initial': {}", _initial_tablets.value()) : "");
|
||
}
|
||
}
|
||
os << ";";
|
||
|
||
return std::move(os).to_managed_string();
|
||
});
|
||
|
||
return cql3::description {
|
||
.keyspace = name(),
|
||
.type = "keyspace",
|
||
.name = name(),
|
||
.create_statement = std::move(maybe_create_statement)
|
||
};
|
||
}
|
||
|
||
} // namespace data_dictionary
|
||
|
||
template <>
|
||
struct fmt::formatter<data_dictionary::user_types_metadata> {
|
||
constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
|
||
auto format(const data_dictionary::user_types_metadata& m, fmt::format_context& ctx) const
|
||
-> decltype(ctx.out()) {
|
||
return fmt::format_to(ctx.out(),
|
||
"org.apache.cassandra.config.UTMetaData@{}",
|
||
fmt::ptr(&m));
|
||
}
|
||
};
|
||
|
||
auto fmt::formatter<data_dictionary::keyspace_metadata>::format(const data_dictionary::keyspace_metadata& m, fmt::format_context& ctx) const -> decltype(ctx.out()) {
|
||
fmt::format_to(ctx.out(), "KSMetaData{{name={}, strategyClass={}, strategyOptions={}, cfMetaData={}, durable_writes={}, tablets=",
|
||
m.name(), m.strategy_name(), m.strategy_options(), m.cf_meta_data(), m.durable_writes());
|
||
if (m.initial_tablets()) {
|
||
if (auto initial_tablets = m.initial_tablets().value()) {
|
||
fmt::format_to(ctx.out(), "{{\"initial\":{}}}", initial_tablets);
|
||
} else {
|
||
fmt::format_to(ctx.out(), "{{\"enabled\":true}}");
|
||
}
|
||
} else {
|
||
fmt::format_to(ctx.out(), "{{\"enabled\":false}}");
|
||
}
|
||
return fmt::format_to(ctx.out(), ", userTypes={}}}", m.user_types());
|
||
}
|
||
|
||
auto fmt::formatter<data_dictionary::storage_options>::format(const data_dictionary::storage_options& so, fmt::format_context& ctx) const -> decltype(ctx.out()) {
|
||
auto type = so.type_string() | std::views::transform(&tolower) | std::ranges::to<std::string>();
|
||
return std::visit(overloaded_functor {
|
||
[&ctx] (const data_dictionary::storage_options::local& so) -> decltype(ctx.out()) {
|
||
return fmt::format_to(ctx.out(), "{}", so.dir);
|
||
},
|
||
[&ctx, &type] (const data_dictionary::storage_options::object_storage& so) -> decltype(ctx.out()) {
|
||
return std::visit(overloaded_functor {
|
||
[&] (const sstring& prefix) -> decltype(ctx.out()) {
|
||
return fmt::format_to(ctx.out(), "{}://{}/{}", type, so.bucket, prefix);
|
||
},
|
||
[&] (const table_id& owner) -> decltype(ctx.out()) {
|
||
return fmt::format_to(ctx.out(), "{}://{} (owner {})", type, so.bucket, owner);
|
||
}
|
||
}, so.location);
|
||
}
|
||
}, so.value);
|
||
}
|