OmniSciDB  a987f07e93
 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 338 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().

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

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

244  {
245  CHECK(is_valid_source_type(copy_params));
246 
247  auto catalog = Catalog_Namespace::SysCatalog::instance().getCatalog(db_id);
248  auto foreign_table = std::make_unique<ForeignTable>();
249 
250  *static_cast<TableDescriptor*>(foreign_table.get()) =
251  *table; // copy table related values
252 
253  CHECK(server);
254  foreign_table->foreign_server = server;
255 
256  // populate options for regex filtering of file-paths in supported data types
260  if (copy_params.regex_path_filter.has_value()) {
262  copy_params.regex_path_filter.value();
263  }
264  if (copy_params.file_sort_order_by.has_value()) {
266  copy_params.file_sort_order_by.value();
267  }
268  if (copy_params.file_sort_regex.has_value()) {
270  copy_params.file_sort_regex.value();
271  }
272  foreign_table->options[AbstractFileStorageDataWrapper::THREADS_KEY] =
274  }
275 
277  CHECK(!copy_params.line_regex.empty());
278  foreign_table->options[RegexFileBufferParser::LINE_REGEX_KEY] =
279  copy_params.line_regex;
280  if (!copy_params.line_start_regex.empty()) {
281  foreign_table->options[RegexFileBufferParser::LINE_START_REGEX_KEY] =
282  copy_params.line_start_regex;
283  }
285  set_header_option(foreign_table->options, copy_params.has_header);
286  }
287  }
288 
289  // setup data source options based on various criteria
290  if (copy_params.source_type == import_export::SourceType::kOdbc) {
291  throw std::runtime_error("ODBC storage not supported");
292  } else if (is_s3_uri(copy_from_source)) {
293  throw std::runtime_error("AWS storage not supported");
294  } else {
295  foreign_table->options["FILE_PATH"] = copy_from_source;
296  }
297 
298  // for CSV import
300  foreign_table->options[CsvFileBufferParser::DELIMITER_KEY] = copy_params.delimiter;
301  foreign_table->options[CsvFileBufferParser::NULLS_KEY] = copy_params.null_str;
302  set_header_option(foreign_table->options, copy_params.has_header);
303  foreign_table->options[CsvFileBufferParser::QUOTED_KEY] =
304  bool_to_option_value(copy_params.quoted);
305  foreign_table->options[CsvFileBufferParser::QUOTE_KEY] = copy_params.quote;
306  foreign_table->options[CsvFileBufferParser::ESCAPE_KEY] = copy_params.escape;
307  foreign_table->options[CsvFileBufferParser::LINE_DELIMITER_KEY] =
308  copy_params.line_delim;
309  foreign_table->options[CsvFileBufferParser::ARRAY_DELIMITER_KEY] =
310  copy_params.array_delim;
311  const std::array<char, 3> array_marker{
312  copy_params.array_begin, copy_params.array_end, 0};
313  foreign_table->options[CsvFileBufferParser::ARRAY_MARKER_KEY] = array_marker.data();
314  foreign_table->options[CsvFileBufferParser::LONLAT_KEY] =
315  bool_to_option_value(copy_params.lonlat);
316  foreign_table->options[CsvFileBufferParser::GEO_ASSIGN_RENDER_GROUPS_KEY] =
318  if (copy_params.geo_explode_collections) {
319  throw std::runtime_error(
320  "geo_explode_collections is not yet supported for FSI CSV import");
321  }
322  foreign_table->options[CsvFileBufferParser::GEO_EXPLODE_COLLECTIONS_KEY] =
324  foreign_table->options[CsvFileBufferParser::SOURCE_SRID_KEY] =
325  std::to_string(copy_params.source_srid);
326 
327  foreign_table->options[TextFileBufferParser::BUFFER_SIZE_KEY] =
328  std::to_string(copy_params.buffer_size);
329 
330  foreign_table->options[CsvFileBufferParser::TRIM_SPACES_KEY] =
331  bool_to_option_value(copy_params.trim_spaces);
332  }
333 
334  foreign_table->initializeOptions();
335  return foreign_table;
336 }
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:289
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 137 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().

141  {
142  auto data_wrapper_type = get_data_wrapper_type(copy_params);
143  CHECK(is_valid_data_wrapper(data_wrapper_type));
144 
145  if (data_wrapper_type == DataWrapperType::CSV) {
146  return std::make_unique<CsvDataWrapper>(
147  db_id, foreign_table, user_mapping, /*disable_cache=*/true);
148  } else if (data_wrapper_type == DataWrapperType::REGEX_PARSER) {
149  return std::make_unique<RegexParserDataWrapper>(
150  db_id, foreign_table, user_mapping, true);
151  }
152 #ifdef ENABLE_IMPORT_PARQUET
153  else if (data_wrapper_type == DataWrapperType::PARQUET) {
154  return std::make_unique<ParquetDataWrapper>(
155  db_id, foreign_table, /*do_metadata_stats_validation=*/false);
156  }
157 #endif
158 
159  return {};
160 }
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:289
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 162 of file ForeignDataWrapperFactory.cpp.

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

166  {
167 #ifdef ENABLE_IMPORT_PARQUET
168  // only supported for parquet import path currently
169  CHECK(data_wrapper_type == DataWrapperType::PARQUET);
170  return std::make_unique<ParquetImporter>(db_id, foreign_table, user_mapping);
171 #else
172  return {};
173 #endif
174 }
#define CHECK(condition)
Definition: Logger.h:289
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 370 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().

372  {
373  bool is_s3_select_wrapper{false};
374  std::string data_wrapper_type_key{data_wrapper_type};
375  constexpr const char* S3_SELECT_WRAPPER_KEY = "CSV_S3_SELECT";
376  if (foreign_table && data_wrapper_type == DataWrapperType::CSV &&
378  is_s3_select_wrapper = true;
379  data_wrapper_type_key = S3_SELECT_WRAPPER_KEY;
380  }
381 
382  if (validation_data_wrappers_.find(data_wrapper_type_key) ==
384  if (data_wrapper_type == DataWrapperType::CSV) {
385  if (is_s3_select_wrapper) {
386  UNREACHABLE();
387  } else {
388  validation_data_wrappers_[data_wrapper_type_key] =
389  std::make_unique<CsvDataWrapper>();
390  }
391 #ifdef ENABLE_IMPORT_PARQUET
392  } else if (data_wrapper_type == DataWrapperType::PARQUET) {
393  validation_data_wrappers_[data_wrapper_type_key] =
394  std::make_unique<ParquetDataWrapper>();
395 #endif
396  } else if (data_wrapper_type == DataWrapperType::REGEX_PARSER) {
397  validation_data_wrappers_[data_wrapper_type_key] =
398  std::make_unique<RegexParserDataWrapper>();
399  } else if (data_wrapper_type == DataWrapperType::INTERNAL_CATALOG) {
400  validation_data_wrappers_[data_wrapper_type_key] =
401  std::make_unique<InternalCatalogDataWrapper>();
402  } else if (data_wrapper_type == DataWrapperType::INTERNAL_MEMORY_STATS) {
403  validation_data_wrappers_[data_wrapper_type_key] =
404  std::make_unique<InternalMemoryStatsDataWrapper>();
405  } else if (data_wrapper_type == DataWrapperType::INTERNAL_STORAGE_STATS) {
406  validation_data_wrappers_[data_wrapper_type_key] =
407  std::make_unique<InternalStorageStatsDataWrapper>();
408  } else if (data_wrapper_type == DataWrapperType::INTERNAL_LOGS) {
409  validation_data_wrappers_[data_wrapper_type_key] =
410  std::make_unique<InternalLogsDataWrapper>();
411  } else {
412  UNREACHABLE();
413  }
414  }
415  CHECK(validation_data_wrappers_.find(data_wrapper_type_key) !=
417  return *validation_data_wrappers_[data_wrapper_type_key];
418 }
static constexpr char const * REGEX_PARSER
static constexpr char const * INTERNAL_STORAGE_STATS
#define UNREACHABLE()
Definition: Logger.h:333
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:289
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 177 of file ForeignDataWrapperFactory.cpp.

Referenced by foreign_storage::create_proxy_fsi_objects().

182  {
183  return {};
184 }

+ 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 420 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().

421  {
422  const auto& supported_wrapper_types = DataWrapperType::supported_data_wrapper_types;
423  if (std::find(supported_wrapper_types.begin(),
424  supported_wrapper_types.end(),
425  data_wrapper_type) == supported_wrapper_types.end()) {
426  std::vector<std::string_view> user_facing_wrapper_types;
427  for (const auto& type : supported_wrapper_types) {
429  user_facing_wrapper_types.emplace_back(type);
430  }
431  }
432  throw std::runtime_error{"Invalid data wrapper type \"" + data_wrapper_type +
433  "\". Data wrapper type must be one of the following: " +
434  join(user_facing_wrapper_types, ", ") + "."};
435  }
436 }
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: