OmniSciDB  c0231cc57d
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
foreign_storage::ForeignDataWrapperFactory Class Reference

#include <ForeignDataWrapperFactory.h>

Static Public Member Functions

static std::unique_ptr
< ForeignDataWrapper
create (const std::string &data_wrapper_type, const int db_id, const ForeignTable *foreign_table)
 
static std::unique_ptr
< UserMapping
createUserMappingProxyIfApplicable (const int db_id, const int user_id, const std::string &file_path, const import_export::CopyParams &copy_params, const ForeignServer *server)
 
static std::unique_ptr
< ForeignServer
createForeignServerProxy (const int db_id, const int user_id, const std::string &file_path, const import_export::CopyParams &copy_params)
 
static std::unique_ptr
< ForeignTable
createForeignTableProxy (const int db_id, const TableDescriptor *table, const std::string &file_path, const import_export::CopyParams &copy_params, const ForeignServer *server)
 
static std::unique_ptr
< ForeignDataWrapper
createForImport (const std::string &data_wrapper_type, const int db_id, const ForeignTable *foreign_table, const UserMapping *user_mapping)
 
static std::unique_ptr
< ForeignDataWrapper
createForGeneralImport (const import_export::CopyParams &copy_params, const int db_id, const ForeignTable *foreign_table, const UserMapping *user_mapping)
 
static const ForeignDataWrappercreateForValidation (const std::string &data_wrapper_type, const ForeignTable *foreign_table=nullptr)
 
static void validateDataWrapperType (const std::string &data_wrapper_type)
 

Static Private Attributes

static std::map< std::string,
std::unique_ptr
< ForeignDataWrapper > > 
validation_data_wrappers_
 

Detailed Description

Definition at line 101 of file ForeignDataWrapperFactory.h.

Member Function Documentation

std::unique_ptr< ForeignDataWrapper > foreign_storage::ForeignDataWrapperFactory::create ( const std::string &  data_wrapper_type,
const int  db_id,
const ForeignTable foreign_table 
)
static

Creates an instance of a ForeignDataWrapper for the given data wrapper type using provided database and foreign table details.

Definition at line 339 of file ForeignDataWrapperFactory.cpp.

References foreign_storage::DataWrapperType::CSV, foreign_storage::DataWrapperType::INTERNAL_CATALOG, foreign_storage::DataWrapperType::INTERNAL_LOGS, foreign_storage::DataWrapperType::INTERNAL_MEMORY_STATS, foreign_storage::DataWrapperType::INTERNAL_STORAGE_STATS, foreign_storage::DataWrapperType::PARQUET, foreign_storage::DataWrapperType::REGEX_PARSER, UNREACHABLE, and foreign_storage::CsvDataWrapper::validateAndGetIsS3Select().

342  {
343  std::unique_ptr<ForeignDataWrapper> data_wrapper;
344  if (data_wrapper_type == DataWrapperType::CSV) {
345  if (CsvDataWrapper::validateAndGetIsS3Select(foreign_table)) {
346  UNREACHABLE();
347  } else {
348  data_wrapper = std::make_unique<CsvDataWrapper>(db_id, foreign_table);
349  }
350 #ifdef ENABLE_IMPORT_PARQUET
351  } else if (data_wrapper_type == DataWrapperType::PARQUET) {
352  data_wrapper = std::make_unique<ParquetDataWrapper>(db_id, foreign_table);
353 #endif
354  } else if (data_wrapper_type == DataWrapperType::REGEX_PARSER) {
355  data_wrapper = std::make_unique<RegexParserDataWrapper>(db_id, foreign_table);
356  } else if (data_wrapper_type == DataWrapperType::INTERNAL_CATALOG) {
357  data_wrapper = std::make_unique<InternalCatalogDataWrapper>(db_id, foreign_table);
358  } else if (data_wrapper_type == DataWrapperType::INTERNAL_MEMORY_STATS) {
359  data_wrapper = std::make_unique<InternalMemoryStatsDataWrapper>(db_id, foreign_table);
360  } else if (data_wrapper_type == DataWrapperType::INTERNAL_STORAGE_STATS) {
361  data_wrapper =
362  std::make_unique<InternalStorageStatsDataWrapper>(db_id, foreign_table);
363  } else if (data_wrapper_type == DataWrapperType::INTERNAL_LOGS) {
364  data_wrapper = std::make_unique<InternalLogsDataWrapper>(db_id, foreign_table);
365  } else {
366  throw std::runtime_error("Unsupported data wrapper");
367  }
368  return data_wrapper;
369 }
static constexpr char const * REGEX_PARSER
static constexpr char const * INTERNAL_STORAGE_STATS
#define UNREACHABLE()
Definition: Logger.h:266
static bool validateAndGetIsS3Select(const ForeignTable *foreign_table)
static constexpr char const * INTERNAL_CATALOG
static constexpr char const * INTERNAL_MEMORY_STATS
static constexpr char const * CSV
static constexpr char const * INTERNAL_LOGS
static constexpr char const * PARQUET

+ Here is the call graph for this function:

std::unique_ptr< ForeignServer > foreign_storage::ForeignDataWrapperFactory::createForeignServerProxy ( const int  db_id,
const int  user_id,
const std::string &  file_path,
const import_export::CopyParams copy_params 
)
static

Definition at line 187 of file ForeignDataWrapperFactory.cpp.

References CHECK, foreign_storage::DataWrapperType::CSV, foreign_storage::is_s3_uri(), foreign_storage::is_valid_source_type(), import_export::kDelimitedFile, import_export::kOdbc, import_export::kParquetFile, import_export::kRegexParsedFile, foreign_storage::AbstractFileStorageDataWrapper::LOCAL_FILE_STORAGE_TYPE, foreign_storage::DataWrapperType::PARQUET, foreign_storage::DataWrapperType::REGEX_PARSER, import_export::CopyParams::source_type, foreign_storage::AbstractFileStorageDataWrapper::STORAGE_TYPE_KEY, and UNREACHABLE.

Referenced by foreign_storage::create_proxy_fsi_objects().

191  {
192  CHECK(is_valid_source_type(copy_params));
193 
194  auto foreign_server = std::make_unique<foreign_storage::ForeignServer>();
195 
196  foreign_server->id = -1;
197  foreign_server->user_id = user_id;
199  foreign_server->data_wrapper_type = DataWrapperType::CSV;
200  } else if (copy_params.source_type == import_export::SourceType::kRegexParsedFile) {
201  foreign_server->data_wrapper_type = DataWrapperType::REGEX_PARSER;
202 #ifdef ENABLE_IMPORT_PARQUET
203  } else if (copy_params.source_type == import_export::SourceType::kParquetFile) {
204  foreign_server->data_wrapper_type = DataWrapperType::PARQUET;
205 #endif
206  } else {
207  UNREACHABLE();
208  }
209  foreign_server->name = "import_proxy_server";
210 
211  if (copy_params.source_type == import_export::SourceType::kOdbc) {
212  throw std::runtime_error("ODBC storage not supported");
213  } else if (is_s3_uri(file_path)) {
214  throw std::runtime_error("AWS storage not supported");
215  } else {
216  foreign_server->options[AbstractFileStorageDataWrapper::STORAGE_TYPE_KEY] =
218  }
219 
220  return foreign_server;
221 }
static constexpr char const * REGEX_PARSER
#define UNREACHABLE()
Definition: Logger.h:266
import_export::SourceType source_type
Definition: CopyParams.h:57
bool is_valid_source_type(const import_export::CopyParams &copy_params)
bool is_s3_uri(const std::string &file_path)
#define CHECK(condition)
Definition: Logger.h:222
static constexpr char const * CSV
static constexpr char const * PARQUET

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::unique_ptr< ForeignTable > foreign_storage::ForeignDataWrapperFactory::createForeignTableProxy ( const int  db_id,
const TableDescriptor table,
const std::string &  file_path,
const import_export::CopyParams copy_params,
const ForeignServer server 
)
static

Definition at line 240 of file ForeignDataWrapperFactory.cpp.

References import_export::CopyParams::array_begin, import_export::CopyParams::array_delim, foreign_storage::CsvFileBufferParser::ARRAY_DELIMITER_KEY, import_export::CopyParams::array_end, foreign_storage::CsvFileBufferParser::ARRAY_MARKER_KEY, foreign_storage::bool_to_option_value(), import_export::CopyParams::buffer_size, foreign_storage::TextFileBufferParser::BUFFER_SIZE_KEY, CHECK, import_export::CopyParams::delimiter, foreign_storage::CsvFileBufferParser::DELIMITER_KEY, import_export::CopyParams::escape, foreign_storage::CsvFileBufferParser::ESCAPE_KEY, import_export::CopyParams::file_sort_order_by, foreign_storage::AbstractFileStorageDataWrapper::FILE_SORT_ORDER_BY_KEY, import_export::CopyParams::file_sort_regex, foreign_storage::AbstractFileStorageDataWrapper::FILE_SORT_REGEX_KEY, import_export::CopyParams::geo_assign_render_groups, foreign_storage::CsvFileBufferParser::GEO_ASSIGN_RENDER_GROUPS_KEY, import_export::CopyParams::geo_explode_collections, foreign_storage::CsvFileBufferParser::GEO_EXPLODE_COLLECTIONS_KEY, Catalog_Namespace::SysCatalog::getCatalog(), import_export::CopyParams::has_header, Catalog_Namespace::SysCatalog::instance(), foreign_storage::is_s3_uri(), foreign_storage::is_valid_source_type(), import_export::kAutoDetect, import_export::kDelimitedFile, import_export::kOdbc, import_export::kParquetFile, import_export::kRegexParsedFile, import_export::CopyParams::line_delim, foreign_storage::CsvFileBufferParser::LINE_DELIMITER_KEY, import_export::CopyParams::line_regex, foreign_storage::RegexFileBufferParser::LINE_REGEX_KEY, import_export::CopyParams::line_start_regex, foreign_storage::RegexFileBufferParser::LINE_START_REGEX_KEY, import_export::CopyParams::lonlat, foreign_storage::CsvFileBufferParser::LONLAT_KEY, import_export::CopyParams::null_str, foreign_storage::CsvFileBufferParser::NULLS_KEY, import_export::num_import_threads(), foreign_storage::OptionsContainer::options, import_export::CopyParams::quote, foreign_storage::CsvFileBufferParser::QUOTE_KEY, import_export::CopyParams::quoted, foreign_storage::CsvFileBufferParser::QUOTED_KEY, import_export::CopyParams::regex_path_filter, foreign_storage::AbstractFileStorageDataWrapper::REGEX_PATH_FILTER_KEY, foreign_storage::anonymous_namespace{ForeignDataWrapperFactory.cpp}::set_header_option(), import_export::CopyParams::source_srid, foreign_storage::CsvFileBufferParser::SOURCE_SRID_KEY, import_export::CopyParams::source_type, import_export::CopyParams::threads, foreign_storage::AbstractFileStorageDataWrapper::THREADS_KEY, to_string(), import_export::CopyParams::trim_spaces, and foreign_storage::CsvFileBufferParser::TRIM_SPACES_KEY.

Referenced by foreign_storage::create_proxy_fsi_objects().

245  {
246  CHECK(is_valid_source_type(copy_params));
247 
248  auto catalog = Catalog_Namespace::SysCatalog::instance().getCatalog(db_id);
249  auto foreign_table = std::make_unique<ForeignTable>();
250 
251  *static_cast<TableDescriptor*>(foreign_table.get()) =
252  *table; // copy table related values
253 
254  CHECK(server);
255  foreign_table->foreign_server = server;
256 
257  // populate options for regex filtering of file-paths in supported data types
261  if (copy_params.regex_path_filter.has_value()) {
263  copy_params.regex_path_filter.value();
264  }
265  if (copy_params.file_sort_order_by.has_value()) {
267  copy_params.file_sort_order_by.value();
268  }
269  if (copy_params.file_sort_regex.has_value()) {
271  copy_params.file_sort_regex.value();
272  }
273  foreign_table->options[AbstractFileStorageDataWrapper::THREADS_KEY] =
275  }
276 
278  CHECK(!copy_params.line_regex.empty());
279  foreign_table->options[RegexFileBufferParser::LINE_REGEX_KEY] =
280  copy_params.line_regex;
281  if (!copy_params.line_start_regex.empty()) {
282  foreign_table->options[RegexFileBufferParser::LINE_START_REGEX_KEY] =
283  copy_params.line_start_regex;
284  }
286  set_header_option(foreign_table->options, copy_params.has_header);
287  }
288  }
289 
290  // setup data source options based on various criteria
291  if (copy_params.source_type == import_export::SourceType::kOdbc) {
292  throw std::runtime_error("ODBC storage not supported");
293  } else if (is_s3_uri(copy_from_source)) {
294  throw std::runtime_error("AWS storage not supported");
295  } else {
296  foreign_table->options["FILE_PATH"] = copy_from_source;
297  }
298 
299  // for CSV import
301  foreign_table->options[CsvFileBufferParser::DELIMITER_KEY] = copy_params.delimiter;
302  foreign_table->options[CsvFileBufferParser::NULLS_KEY] = copy_params.null_str;
303  set_header_option(foreign_table->options, copy_params.has_header);
304  foreign_table->options[CsvFileBufferParser::QUOTED_KEY] =
305  bool_to_option_value(copy_params.quoted);
306  foreign_table->options[CsvFileBufferParser::QUOTE_KEY] = copy_params.quote;
307  foreign_table->options[CsvFileBufferParser::ESCAPE_KEY] = copy_params.escape;
308  foreign_table->options[CsvFileBufferParser::LINE_DELIMITER_KEY] =
309  copy_params.line_delim;
310  foreign_table->options[CsvFileBufferParser::ARRAY_DELIMITER_KEY] =
311  copy_params.array_delim;
312  const std::array<char, 3> array_marker{
313  copy_params.array_begin, copy_params.array_end, 0};
314  foreign_table->options[CsvFileBufferParser::ARRAY_MARKER_KEY] = array_marker.data();
315  foreign_table->options[CsvFileBufferParser::LONLAT_KEY] =
316  bool_to_option_value(copy_params.lonlat);
317  foreign_table->options[CsvFileBufferParser::GEO_ASSIGN_RENDER_GROUPS_KEY] =
319  if (copy_params.geo_explode_collections) {
320  throw std::runtime_error(
321  "geo_explode_collections is not yet supported for FSI CSV import");
322  }
323  foreign_table->options[CsvFileBufferParser::GEO_EXPLODE_COLLECTIONS_KEY] =
325  foreign_table->options[CsvFileBufferParser::SOURCE_SRID_KEY] =
326  std::to_string(copy_params.source_srid);
327 
328  foreign_table->options[TextFileBufferParser::BUFFER_SIZE_KEY] =
329  std::to_string(copy_params.buffer_size);
330 
331  foreign_table->options[CsvFileBufferParser::TRIM_SPACES_KEY] =
332  bool_to_option_value(copy_params.trim_spaces);
333  }
334 
335  foreign_table->initializeOptions();
336  return foreign_table;
337 }
static const std::string GEO_EXPLODE_COLLECTIONS_KEY
static const std::string TRIM_SPACES_KEY
static const std::string ARRAY_MARKER_KEY
void set_header_option(OptionsMap &options, const import_export::ImportHeaderRow &has_header)
std::string to_string(char const *&&v)
ImportHeaderRow has_header
Definition: CopyParams.h:46
static const std::string SOURCE_SRID_KEY
std::optional< std::string > regex_path_filter
Definition: CopyParams.h:85
static SysCatalog & instance()
Definition: SysCatalog.h:341
std::string bool_to_option_value(const bool value)
static const std::string LINE_DELIMITER_KEY
import_export::SourceType source_type
Definition: CopyParams.h:57
bool is_valid_source_type(const import_export::CopyParams &copy_params)
size_t num_import_threads(const int32_t copy_params_threads)
Definition: thread_count.h:31
bool is_s3_uri(const std::string &file_path)
static const std::string DELIMITER_KEY
std::shared_ptr< Catalog > getCatalog(const std::string &dbName)
static const std::string ARRAY_DELIMITER_KEY
std::string line_start_regex
Definition: CopyParams.h:106
#define CHECK(condition)
Definition: Logger.h:222
static const std::string GEO_ASSIGN_RENDER_GROUPS_KEY
std::optional< std::string > file_sort_order_by
Definition: CopyParams.h:86
std::optional< std::string > file_sort_regex
Definition: CopyParams.h:87

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::unique_ptr< ForeignDataWrapper > foreign_storage::ForeignDataWrapperFactory::createForGeneralImport ( const import_export::CopyParams copy_params,
const int  db_id,
const ForeignTable foreign_table,
const UserMapping user_mapping 
)
static

Definition at line 138 of file ForeignDataWrapperFactory.cpp.

References CHECK, foreign_storage::DataWrapperType::CSV, anonymous_namespace{ForeignDataWrapperFactory.cpp}::get_data_wrapper_type(), anonymous_namespace{ForeignDataWrapperFactory.cpp}::is_valid_data_wrapper(), foreign_storage::DataWrapperType::PARQUET, and foreign_storage::DataWrapperType::REGEX_PARSER.

Referenced by import_export::ForeignDataImporter::importGeneral().

142  {
143  auto data_wrapper_type = get_data_wrapper_type(copy_params);
144  CHECK(is_valid_data_wrapper(data_wrapper_type));
145 
146  if (data_wrapper_type == DataWrapperType::CSV) {
147  return std::make_unique<CsvDataWrapper>(
148  db_id, foreign_table, user_mapping, /*disable_cache=*/true);
149  } else if (data_wrapper_type == DataWrapperType::REGEX_PARSER) {
150  return std::make_unique<RegexParserDataWrapper>(
151  db_id, foreign_table, user_mapping, true);
152  }
153 #ifdef ENABLE_IMPORT_PARQUET
154  else if (data_wrapper_type == DataWrapperType::PARQUET) {
155  return std::make_unique<ParquetDataWrapper>(
156  db_id, foreign_table, /*do_metadata_stats_validation=*/false);
157  }
158 #endif
159 
160  return {};
161 }
bool is_valid_data_wrapper(const std::string &data_wrapper_type)
static constexpr char const * REGEX_PARSER
std::string get_data_wrapper_type(const import_export::CopyParams &copy_params)
#define CHECK(condition)
Definition: Logger.h:222
static constexpr char const * CSV
static constexpr char const * PARQUET

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::unique_ptr< ForeignDataWrapper > foreign_storage::ForeignDataWrapperFactory::createForImport ( const std::string &  data_wrapper_type,
const int  db_id,
const ForeignTable foreign_table,
const UserMapping user_mapping 
)
static

Create for the import use-case.

Definition at line 163 of file ForeignDataWrapperFactory.cpp.

References CHECK, and foreign_storage::DataWrapperType::PARQUET.

167  {
168 #ifdef ENABLE_IMPORT_PARQUET
169  // only supported for parquet import path currently
170  CHECK(data_wrapper_type == DataWrapperType::PARQUET);
171  return std::make_unique<ParquetImporter>(db_id, foreign_table, user_mapping);
172 #else
173  return {};
174 #endif
175 }
#define CHECK(condition)
Definition: Logger.h:222
static constexpr char const * PARQUET
const ForeignDataWrapper & foreign_storage::ForeignDataWrapperFactory::createForValidation ( const std::string &  data_wrapper_type,
const ForeignTable foreign_table = nullptr 
)
static

Creates an instance (or gets an existing instance) of an immutable ForeignDataWrapper to be used for validation purposes. Returned instance should not be used for any stateful operations, such as fetching foreign table data/metadata.

Definition at line 371 of file ForeignDataWrapperFactory.cpp.

References CHECK, foreign_storage::DataWrapperType::CSV, foreign_storage::DataWrapperType::INTERNAL_CATALOG, foreign_storage::DataWrapperType::INTERNAL_LOGS, foreign_storage::DataWrapperType::INTERNAL_MEMORY_STATS, foreign_storage::DataWrapperType::INTERNAL_STORAGE_STATS, foreign_storage::DataWrapperType::PARQUET, foreign_storage::DataWrapperType::REGEX_PARSER, UNREACHABLE, foreign_storage::CsvDataWrapper::validateAndGetIsS3Select(), and validation_data_wrappers_.

Referenced by foreign_storage::ForeignServer::validateStorageParameters().

373  {
374  bool is_s3_select_wrapper{false};
375  std::string data_wrapper_type_key{data_wrapper_type};
376  constexpr const char* S3_SELECT_WRAPPER_KEY = "CSV_S3_SELECT";
377  if (foreign_table && data_wrapper_type == DataWrapperType::CSV &&
379  is_s3_select_wrapper = true;
380  data_wrapper_type_key = S3_SELECT_WRAPPER_KEY;
381  }
382 
383  if (validation_data_wrappers_.find(data_wrapper_type_key) ==
385  if (data_wrapper_type == DataWrapperType::CSV) {
386  if (is_s3_select_wrapper) {
387  UNREACHABLE();
388  } else {
389  validation_data_wrappers_[data_wrapper_type_key] =
390  std::make_unique<CsvDataWrapper>();
391  }
392 #ifdef ENABLE_IMPORT_PARQUET
393  } else if (data_wrapper_type == DataWrapperType::PARQUET) {
394  validation_data_wrappers_[data_wrapper_type_key] =
395  std::make_unique<ParquetDataWrapper>();
396 #endif
397  } else if (data_wrapper_type == DataWrapperType::REGEX_PARSER) {
398  validation_data_wrappers_[data_wrapper_type_key] =
399  std::make_unique<RegexParserDataWrapper>();
400  } else if (data_wrapper_type == DataWrapperType::INTERNAL_CATALOG) {
401  validation_data_wrappers_[data_wrapper_type_key] =
402  std::make_unique<InternalCatalogDataWrapper>();
403  } else if (data_wrapper_type == DataWrapperType::INTERNAL_MEMORY_STATS) {
404  validation_data_wrappers_[data_wrapper_type_key] =
405  std::make_unique<InternalMemoryStatsDataWrapper>();
406  } else if (data_wrapper_type == DataWrapperType::INTERNAL_STORAGE_STATS) {
407  validation_data_wrappers_[data_wrapper_type_key] =
408  std::make_unique<InternalStorageStatsDataWrapper>();
409  } else if (data_wrapper_type == DataWrapperType::INTERNAL_LOGS) {
410  validation_data_wrappers_[data_wrapper_type_key] =
411  std::make_unique<InternalLogsDataWrapper>();
412  } else {
413  UNREACHABLE();
414  }
415  }
416  CHECK(validation_data_wrappers_.find(data_wrapper_type_key) !=
418  return *validation_data_wrappers_[data_wrapper_type_key];
419 }
static constexpr char const * REGEX_PARSER
static constexpr char const * INTERNAL_STORAGE_STATS
#define UNREACHABLE()
Definition: Logger.h:266
static bool validateAndGetIsS3Select(const ForeignTable *foreign_table)
static constexpr char const * INTERNAL_CATALOG
static std::map< std::string, std::unique_ptr< ForeignDataWrapper > > validation_data_wrappers_
static constexpr char const * INTERNAL_MEMORY_STATS
#define CHECK(condition)
Definition: Logger.h:222
static constexpr char const * CSV
static constexpr char const * INTERNAL_LOGS
static constexpr char const * PARQUET

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::unique_ptr< UserMapping > foreign_storage::ForeignDataWrapperFactory::createUserMappingProxyIfApplicable ( const int  db_id,
const int  user_id,
const std::string &  file_path,
const import_export::CopyParams copy_params,
const ForeignServer server 
)
static

Definition at line 178 of file ForeignDataWrapperFactory.cpp.

Referenced by foreign_storage::create_proxy_fsi_objects().

183  {
184  return {};
185 }

+ Here is the caller graph for this function:

void foreign_storage::ForeignDataWrapperFactory::validateDataWrapperType ( const std::string &  data_wrapper_type)
static

Checks that the given data wrapper type is valid.

Definition at line 421 of file ForeignDataWrapperFactory.cpp.

References shared::contains(), foreign_storage::DataWrapperType::INTERNAL_DATA_WRAPPERS, join(), foreign_storage::DataWrapperType::supported_data_wrapper_types, and run_benchmark_import::type.

Referenced by foreign_storage::ForeignServer::validate().

422  {
423  const auto& supported_wrapper_types = DataWrapperType::supported_data_wrapper_types;
424  if (std::find(supported_wrapper_types.begin(),
425  supported_wrapper_types.end(),
426  data_wrapper_type) == supported_wrapper_types.end()) {
427  std::vector<std::string_view> user_facing_wrapper_types;
428  for (const auto& type : supported_wrapper_types) {
430  user_facing_wrapper_types.emplace_back(type);
431  }
432  }
433  throw std::runtime_error{"Invalid data wrapper type \"" + data_wrapper_type +
434  "\". Data wrapper type must be one of the following: " +
435  join(user_facing_wrapper_types, ", ") + "."};
436  }
437 }
bool contains(const T &container, const U &element)
Definition: misc.h:195
static constexpr std::array< std::string_view, 7 > supported_data_wrapper_types
std::string join(T const &container, std::string const &delim)
static constexpr std::array< char const *, 4 > INTERNAL_DATA_WRAPPERS

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Member Data Documentation

std::map< std::string, std::unique_ptr< ForeignDataWrapper > > foreign_storage::ForeignDataWrapperFactory::validation_data_wrappers_
staticprivate

Definition at line 162 of file ForeignDataWrapperFactory.h.

Referenced by createForValidation().


The documentation for this class was generated from the following files: