OmniSciDB  a5dc49c757
 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 107 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 343 of file ForeignDataWrapperFactory.cpp.

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

346  {
347  std::unique_ptr<ForeignDataWrapper> data_wrapper;
348  if (data_wrapper_type == DataWrapperType::CSV) {
349  if (CsvDataWrapper::validateAndGetIsS3Select(foreign_table)) {
350  UNREACHABLE();
351  } else {
352  data_wrapper = std::make_unique<CsvDataWrapper>(db_id, foreign_table);
353  }
354 #ifdef ENABLE_IMPORT_PARQUET
355  } else if (data_wrapper_type == DataWrapperType::PARQUET) {
356  data_wrapper = std::make_unique<ParquetDataWrapper>(db_id, foreign_table);
357 #endif
358  } else if (data_wrapper_type == DataWrapperType::REGEX_PARSER) {
359  data_wrapper = std::make_unique<RegexParserDataWrapper>(db_id, foreign_table);
360  } else if (data_wrapper_type == DataWrapperType::INTERNAL_CATALOG) {
361  data_wrapper = std::make_unique<InternalCatalogDataWrapper>(db_id, foreign_table);
362  } else if (data_wrapper_type == DataWrapperType::INTERNAL_EXECUTOR_STATS) {
363  data_wrapper =
364  std::make_unique<InternalExecutorStatsDataWrapper>(db_id, foreign_table);
365  } else if (data_wrapper_type == DataWrapperType::INTERNAL_ML_MODEL_METADATA) {
366  data_wrapper =
367  std::make_unique<InternalMLModelMetadataDataWrapper>(db_id, foreign_table);
368  } else if (data_wrapper_type == DataWrapperType::INTERNAL_MEMORY_STATS) {
369  data_wrapper = std::make_unique<InternalMemoryStatsDataWrapper>(db_id, foreign_table);
370  } else if (data_wrapper_type == DataWrapperType::INTERNAL_STORAGE_STATS) {
371  data_wrapper =
372  std::make_unique<InternalStorageStatsDataWrapper>(db_id, foreign_table);
373  } else if (data_wrapper_type == DataWrapperType::INTERNAL_LOGS) {
374  data_wrapper = std::make_unique<InternalLogsDataWrapper>(db_id, foreign_table);
375  } else {
376  throw std::runtime_error("Unsupported data wrapper");
377  }
378  return data_wrapper;
379 }
static constexpr char const * REGEX_PARSER
static constexpr char const * INTERNAL_STORAGE_STATS
#define UNREACHABLE()
Definition: Logger.h:338
static bool validateAndGetIsS3Select(const ForeignTable *foreign_table)
static constexpr char const * INTERNAL_CATALOG
static constexpr char const * INTERNAL_ML_MODEL_METADATA
static constexpr char const * INTERNAL_EXECUTOR_STATS
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 184 of file ForeignDataWrapperFactory.cpp.

References CHECK, foreign_storage::DataWrapperType::CSV, shared::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().

188  {
189  CHECK(is_valid_source_type(copy_params));
190 
191  auto foreign_server = std::make_unique<foreign_storage::ForeignServer>();
192 
193  foreign_server->id = -1;
194  foreign_server->user_id = user_id;
196  foreign_server->data_wrapper_type = DataWrapperType::CSV;
197  } else if (copy_params.source_type == import_export::SourceType::kRegexParsedFile) {
198  foreign_server->data_wrapper_type = DataWrapperType::REGEX_PARSER;
199 #ifdef ENABLE_IMPORT_PARQUET
200  } else if (copy_params.source_type == import_export::SourceType::kParquetFile) {
201  foreign_server->data_wrapper_type = DataWrapperType::PARQUET;
202 #endif
203  } else {
204  UNREACHABLE();
205  }
206  foreign_server->name = "import_proxy_server";
207 
208  if (copy_params.source_type == import_export::SourceType::kOdbc) {
209  throw std::runtime_error("ODBC storage not supported");
210  } else if (shared::is_s3_uri(file_path)) {
211  throw std::runtime_error("AWS storage not supported");
212  } else {
213  foreign_server->options[AbstractFileStorageDataWrapper::STORAGE_TYPE_KEY] =
215  }
216 
217  return foreign_server;
218 }
static constexpr char const * REGEX_PARSER
bool is_s3_uri(const std::string &file_path)
#define UNREACHABLE()
Definition: Logger.h:338
import_export::SourceType source_type
Definition: CopyParams.h:57
bool is_valid_source_type(const import_export::CopyParams &copy_params)
#define CHECK(condition)
Definition: Logger.h:291
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 237 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_explode_collections, foreign_storage::CsvFileBufferParser::GEO_EXPLODE_COLLECTIONS_KEY, import_export::CopyParams::geo_validate_geometry, foreign_storage::ForeignTable::GEO_VALIDATE_GEOMETRY_KEY, Catalog_Namespace::SysCatalog::getCatalog(), import_export::CopyParams::has_header, Catalog_Namespace::SysCatalog::instance(), shared::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().

242  {
243  CHECK(is_valid_source_type(copy_params));
244 
245  auto catalog = Catalog_Namespace::SysCatalog::instance().getCatalog(db_id);
246  auto foreign_table = std::make_unique<ForeignTable>();
247 
248  *static_cast<TableDescriptor*>(foreign_table.get()) =
249  *table; // copy table related values
250 
251  CHECK(server);
252  foreign_table->foreign_server = server;
253 
254  // enable geo validation in most/all source types
259  foreign_table->options[ForeignTable::GEO_VALIDATE_GEOMETRY_KEY] =
261  }
262 
263  // populate options for regex filtering of file-paths in supported data types
267  if (copy_params.regex_path_filter.has_value()) {
269  copy_params.regex_path_filter.value();
270  }
271  if (copy_params.file_sort_order_by.has_value()) {
273  copy_params.file_sort_order_by.value();
274  }
275  if (copy_params.file_sort_regex.has_value()) {
277  copy_params.file_sort_regex.value();
278  }
279  foreign_table->options[AbstractFileStorageDataWrapper::THREADS_KEY] =
281  }
282 
284  CHECK(!copy_params.line_regex.empty());
285  foreign_table->options[RegexFileBufferParser::LINE_REGEX_KEY] =
286  copy_params.line_regex;
287  if (!copy_params.line_start_regex.empty()) {
288  foreign_table->options[RegexFileBufferParser::LINE_START_REGEX_KEY] =
289  copy_params.line_start_regex;
290  }
292  set_header_option(foreign_table->options, copy_params.has_header);
293  }
294  }
295 
296  // setup data source options based on various criteria
297  if (copy_params.source_type == import_export::SourceType::kOdbc) {
298  throw std::runtime_error("ODBC storage not supported");
299  } else if (shared::is_s3_uri(copy_from_source)) {
300  throw std::runtime_error("AWS storage not supported");
301  } else {
302  foreign_table->options["FILE_PATH"] = copy_from_source;
303  }
304 
305  // for CSV import
307  foreign_table->options[CsvFileBufferParser::DELIMITER_KEY] = copy_params.delimiter;
308  foreign_table->options[CsvFileBufferParser::NULLS_KEY] = copy_params.null_str;
309  set_header_option(foreign_table->options, copy_params.has_header);
310  foreign_table->options[CsvFileBufferParser::QUOTED_KEY] =
311  bool_to_option_value(copy_params.quoted);
312  foreign_table->options[CsvFileBufferParser::QUOTE_KEY] = copy_params.quote;
313  foreign_table->options[CsvFileBufferParser::ESCAPE_KEY] = copy_params.escape;
314  foreign_table->options[CsvFileBufferParser::LINE_DELIMITER_KEY] =
315  copy_params.line_delim;
316  foreign_table->options[CsvFileBufferParser::ARRAY_DELIMITER_KEY] =
317  copy_params.array_delim;
318  const std::array<char, 3> array_marker{
319  copy_params.array_begin, copy_params.array_end, 0};
320  foreign_table->options[CsvFileBufferParser::ARRAY_MARKER_KEY] = array_marker.data();
321  foreign_table->options[CsvFileBufferParser::LONLAT_KEY] =
322  bool_to_option_value(copy_params.lonlat);
323  if (copy_params.geo_explode_collections) {
324  throw std::runtime_error(
325  "geo_explode_collections is not yet supported for FSI CSV import");
326  }
327  foreign_table->options[CsvFileBufferParser::GEO_EXPLODE_COLLECTIONS_KEY] =
329  foreign_table->options[CsvFileBufferParser::SOURCE_SRID_KEY] =
330  std::to_string(copy_params.source_srid);
331 
332  foreign_table->options[TextFileBufferParser::BUFFER_SIZE_KEY] =
333  std::to_string(copy_params.buffer_size);
334 
335  foreign_table->options[CsvFileBufferParser::TRIM_SPACES_KEY] =
336  bool_to_option_value(copy_params.trim_spaces);
337  }
338 
339  foreign_table->initializeOptions();
340  return foreign_table;
341 }
static const std::string GEO_EXPLODE_COLLECTIONS_KEY
static const std::string TRIM_SPACES_KEY
static const std::string ARRAY_MARKER_KEY
bool is_s3_uri(const std::string &file_path)
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:343
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
static const std::string DELIMITER_KEY
std::shared_ptr< Catalog > getCatalog(const std::string &dbName)
static constexpr const char * GEO_VALIDATE_GEOMETRY_KEY
Definition: ForeignTable.h:49
static const std::string ARRAY_DELIMITER_KEY
std::string line_start_regex
Definition: CopyParams.h:107
#define CHECK(condition)
Definition: Logger.h:291
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 135 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().

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

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

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

References foreign_storage::DataWrapperType::CSV, foreign_storage::DataWrapperType::INTERNAL_CATALOG, foreign_storage::DataWrapperType::INTERNAL_EXECUTOR_STATS, foreign_storage::DataWrapperType::INTERNAL_LOGS, foreign_storage::DataWrapperType::INTERNAL_MEMORY_STATS, foreign_storage::DataWrapperType::INTERNAL_ML_MODEL_METADATA, 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().

383  {
384  bool is_s3_select_wrapper{false};
385  std::string data_wrapper_type_key{data_wrapper_type};
386  constexpr const char* S3_SELECT_WRAPPER_KEY = "CSV_S3_SELECT";
387  if (foreign_table && data_wrapper_type == DataWrapperType::CSV &&
389  is_s3_select_wrapper = true;
390  data_wrapper_type_key = S3_SELECT_WRAPPER_KEY;
391  }
392 
393  auto [itr, is_new] = validation_data_wrappers_.emplace(data_wrapper_type_key, nullptr);
394  if (is_new) {
395  if (data_wrapper_type == DataWrapperType::CSV) {
396  if (is_s3_select_wrapper) {
397  UNREACHABLE();
398  } else {
399  itr->second = std::make_unique<CsvDataWrapper>();
400  }
401 #ifdef ENABLE_IMPORT_PARQUET
402  } else if (data_wrapper_type == DataWrapperType::PARQUET) {
403  itr->second = std::make_unique<ParquetDataWrapper>();
404 #endif
405  } else if (data_wrapper_type == DataWrapperType::REGEX_PARSER) {
406  itr->second = std::make_unique<RegexParserDataWrapper>();
407  } else if (data_wrapper_type == DataWrapperType::INTERNAL_CATALOG) {
408  itr->second = std::make_unique<InternalCatalogDataWrapper>();
409  } else if (data_wrapper_type == DataWrapperType::INTERNAL_EXECUTOR_STATS) {
410  itr->second = std::make_unique<InternalExecutorStatsDataWrapper>();
411  } else if (data_wrapper_type == DataWrapperType::INTERNAL_ML_MODEL_METADATA) {
412  itr->second = std::make_unique<InternalMLModelMetadataDataWrapper>();
413  } else if (data_wrapper_type == DataWrapperType::INTERNAL_MEMORY_STATS) {
414  itr->second = std::make_unique<InternalMemoryStatsDataWrapper>();
415  } else if (data_wrapper_type == DataWrapperType::INTERNAL_STORAGE_STATS) {
416  itr->second = std::make_unique<InternalStorageStatsDataWrapper>();
417  } else if (data_wrapper_type == DataWrapperType::INTERNAL_LOGS) {
418  itr->second = std::make_unique<InternalLogsDataWrapper>();
419  } else {
420  UNREACHABLE();
421  }
422  }
423  return itr->second.get();
424 }
static constexpr char const * REGEX_PARSER
static constexpr char const * INTERNAL_STORAGE_STATS
#define UNREACHABLE()
Definition: Logger.h:338
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_ML_MODEL_METADATA
static constexpr char const * INTERNAL_EXECUTOR_STATS
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:

+ 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 175 of file ForeignDataWrapperFactory.cpp.

Referenced by foreign_storage::create_proxy_fsi_objects().

180  {
181  return {};
182 }

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

427  {
428  const auto& supported_wrapper_types = DataWrapperType::supported_data_wrapper_types;
429  if (std::find(supported_wrapper_types.begin(),
430  supported_wrapper_types.end(),
431  data_wrapper_type) == supported_wrapper_types.end()) {
432  std::vector<std::string_view> user_facing_wrapper_types;
433  for (const auto& type : supported_wrapper_types) {
435  user_facing_wrapper_types.emplace_back(type);
436  }
437  }
438  throw std::runtime_error{"Invalid data wrapper type \"" + data_wrapper_type +
439  "\". Data wrapper type must be one of the following: " +
440  join(user_facing_wrapper_types, ", ") + "."};
441  }
442 }
bool contains(const T &container, const U &element)
Definition: misc.h:204
std::string join(T const &container, std::string const &delim)
static constexpr std::array< char const *, 6 > INTERNAL_DATA_WRAPPERS
static constexpr std::array< std::string_view, 9 > supported_data_wrapper_types

+ 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 168 of file ForeignDataWrapperFactory.h.

Referenced by createForValidation().


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