#include <ForeignTable.h>

Inheritance diagram for foreign_storage::ForeignTable:

Collaboration diagram for foreign_storage::ForeignTable:

Public Member Functions
void	validate (const std::vector< std::string_view > &supported_data_wrapper_options)

bool	isAppendMode () const

Public Member Functions inherited from TableDescriptor
	TableDescriptor ()

virtual	~TableDescriptor ()=default

Public Member Functions inherited from foreign_storage::OptionsContainer
	OptionsContainer ()

	OptionsContainer (const std::map< std::string, std::string, std::less<>> &options)

	OptionsContainer (const std::string &options_str)

void	populateOptionsMap (const rapidjson::Value &ddl_options)

void	populateOptionsMap (const std::string &options_json, bool clear=false)

std::string	getOptionsAsJsonString () const

Public Attributes
const ForeignServer *	foreign_server

int64_t	last_refresh_time {NULL_REFRESH_TIME}

int64_t	next_refresh_time {NULL_REFRESH_TIME}

Public Attributes inherited from TableDescriptor
int32_t	tableId

int32_t	shard

std::string	tableName

int32_t	userId

int32_t	nColumns

bool	isView

std::string	viewSQL

std::string	fragments

Fragmenter_Namespace::FragmenterType	fragType

int32_t	maxFragRows

int64_t	maxChunkSize

int32_t	fragPageSize

int64_t	maxRows

std::string	partitions

std::string	keyMetainfo

std::shared_ptr < Fragmenter_Namespace::AbstractFragmenter >	fragmenter

int32_t	nShards

int	shardedColumnId

int	sortedColumnId

Data_Namespace::MemoryLevel	persistenceLevel

bool	hasDeletedCol

std::vector< int >	columnIdBySpi_

std::string	storageType

std::shared_ptr< std::mutex >	mutex_

Public Attributes inherited from foreign_storage::OptionsContainer
std::map< std::string, std::string, std::less<> >	options

Static Public Attributes
static constexpr const char *	FRAGMENT_SIZE_KEY = "FRAGMENT_SIZE"

static constexpr const char *	REFRESH_TIMING_TYPE_KEY = "REFRESH_TIMING_TYPE"

static constexpr const char *	REFRESH_START_DATE_TIME_KEY = "REFRESH_START_DATE_TIME"

static constexpr const char *	REFRESH_INTERVAL_KEY = "REFRESH_INTERVAL"

static constexpr const char *	REFRESH_UPDATE_TYPE_KEY = "REFRESH_UPDATE_TYPE"

static constexpr const char *	ALL_REFRESH_UPDATE_TYPE = "ALL"

static constexpr const char *	APPEND_REFRESH_UPDATE_TYPE = "APPEND"

static constexpr const char *	SCHEDULE_REFRESH_TIMING_TYPE = "SCHEDULED"

static constexpr const char *	MANUAL_REFRESH_TIMING_TYPE = "MANUAL"

static constexpr int	NULL_REFRESH_TIME = -1

static constexpr std::array < const char *, 5 >	supported_options

Private Member Functions
void	validateRecognizedOption (const std::vector< std::string_view > &supported_data_wrapper_options)

Detailed Description

Definition at line 27 of file ForeignTable.h.

Member Function Documentation

bool foreign_storage::ForeignTable::isAppendMode ( ) const

inline

Definition at line 98 of file ForeignTable.h.

References APPEND_REFRESH_UPDATE_TYPE, foreign_storage::OptionsContainer::options, and REFRESH_UPDATE_TYPE_KEY.

Referenced by foreign_storage::CsvDataWrapper::populateChunkMetadata(), foreign_storage::ForeignStorageMgr::refreshTableInCache(), and foreign_storage::CsvDataWrapper::restoreDataWrapperInternals().

                             {
     auto update_mode = options.find(REFRESH_UPDATE_TYPE_KEY);
     return (update_mode != options.end() &&
             update_mode->second == APPEND_REFRESH_UPDATE_TYPE);
   }

Here is the caller graph for this function:

void foreign_storage::ForeignTable::validate ( const std::vector< std::string_view > & supported_data_wrapper_options )

inline

Definition at line 48 of file ForeignTable.h.

References ALL_REFRESH_UPDATE_TYPE, APPEND_REFRESH_UPDATE_TYPE, CHECK(), dateTimeParse< kTIMESTAMP >(), MANUAL_REFRESH_TIMING_TYPE, foreign_storage::OptionsContainer::options, REFRESH_INTERVAL_KEY, REFRESH_START_DATE_TIME_KEY, REFRESH_TIMING_TYPE_KEY, REFRESH_UPDATE_TYPE_KEY, SCHEDULE_REFRESH_TIMING_TYPE, and validateRecognizedOption().

                                                                                  {
     auto update_type_entry =
         options.find(foreign_storage::ForeignTable::REFRESH_UPDATE_TYPE_KEY);
     CHECK(update_type_entry != options.end());
     if (update_type_entry->second != ALL_REFRESH_UPDATE_TYPE &&
         update_type_entry->second != APPEND_REFRESH_UPDATE_TYPE) {
       std::string error_message = "Invalid value \"" + update_type_entry->second +
                                   "\" for " + REFRESH_UPDATE_TYPE_KEY + " option." +
                                   " Value must be \"" +
                                   std::string{APPEND_REFRESH_UPDATE_TYPE} + "\" or \"" +
                                   std::string{ALL_REFRESH_UPDATE_TYPE} + "\".";
       throw std::runtime_error{error_message};
     }
 
     auto refresh_timing_entry =
         options.find(foreign_storage::ForeignTable::REFRESH_TIMING_TYPE_KEY);
     CHECK(refresh_timing_entry != options.end());
     if (refresh_timing_entry->second == SCHEDULE_REFRESH_TIMING_TYPE) {
       auto start_date_entry = options.find(REFRESH_START_DATE_TIME_KEY);
       if (start_date_entry == options.end()) {
         throw std::runtime_error{std::string{REFRESH_START_DATE_TIME_KEY} +
                                  " option must be provided for scheduled refreshes."};
       }
       auto start_date_time = dateTimeParse<kTIMESTAMP>(start_date_entry->second, 0);
       int64_t current_time = std::chrono::duration_cast<std::chrono::seconds>(
                                  std::chrono::system_clock::now().time_since_epoch())
                                  .count();
       if (start_date_time < current_time) {
         throw std::runtime_error{std::string{REFRESH_START_DATE_TIME_KEY} +
                                  " cannot be a past date time."};
       }
 
       auto interval_entry = options.find(REFRESH_INTERVAL_KEY);
       if (interval_entry != options.end()) {
         boost::regex interval_regex{"^\\d{1,}[SHD]$",
                                     boost::regex::extended | boost::regex::icase};
         if (!boost::regex_match(interval_entry->second, interval_regex)) {
           throw std::runtime_error{"Invalid value provided for the " +
                                    std::string{REFRESH_INTERVAL_KEY} + " option."};
         }
       }
     } else if (refresh_timing_entry->second != MANUAL_REFRESH_TIMING_TYPE) {
       throw std::runtime_error{"Invalid value provided for the " +
                                std::string{REFRESH_TIMING_TYPE_KEY} +
                                " option. Value must be \"" + MANUAL_REFRESH_TIMING_TYPE +
                                "\" or \"" + SCHEDULE_REFRESH_TIMING_TYPE + "\"."};
     }
     validateRecognizedOption(supported_data_wrapper_options);
   }

Here is the call graph for this function:

void foreign_storage::ForeignTable::validateRecognizedOption ( const std::vector< std::string_view > & supported_data_wrapper_options )

inlineprivate

Definition at line 105 of file ForeignTable.h.

References foreign_storage::OptionsContainer::options, and supported_options.

Referenced by validate().

                                                                        {
     for (const auto& entry : options) {
       if (std::find(supported_options.begin(), supported_options.end(), entry.first) ==
               supported_options.end() &&
           std::find(supported_data_wrapper_options.begin(),
                     supported_data_wrapper_options.end(),
                     entry.first) == supported_data_wrapper_options.end()) {
         std::string error_message =
             "Invalid foreign table option \"" + entry.first + "\".";
         throw std::runtime_error{error_message};
       }
     }
   }

Here is the caller graph for this function:

Member Data Documentation

constexpr const char* foreign_storage::ForeignTable::ALL_REFRESH_UPDATE_TYPE = "ALL"

static

Definition at line 33 of file ForeignTable.h.

Referenced by CreateForeignTableCommand::setRefreshOptions(), and validate().

constexpr const char* foreign_storage::ForeignTable::APPEND_REFRESH_UPDATE_TYPE = "APPEND"

static

Definition at line 34 of file ForeignTable.h.

Referenced by isAppendMode(), and validate().

const ForeignServer* foreign_storage::ForeignTable::foreign_server

Definition at line 39 of file ForeignTable.h.

Referenced by foreign_storage::ParquetDataWrapper::getFilePath(), foreign_storage::CsvDataWrapper::getFilePath(), foreign_storage::ParquetDataWrapper::ParquetDataWrapper(), foreign_storage::CsvDataWrapper::populateChunkMetadata(), foreign_storage::CsvDataWrapper::restoreDataWrapperInternals(), foreign_storage::ParquetDataWrapper::validateFilePath(), and foreign_storage::CsvDataWrapper::validateFilePath().

constexpr const char* foreign_storage::ForeignTable::FRAGMENT_SIZE_KEY = "FRAGMENT_SIZE"

static

Definition at line 28 of file ForeignTable.h.

int64_t foreign_storage::ForeignTable::last_refresh_time {NULL_REFRESH_TIME}

Definition at line 40 of file ForeignTable.h.

constexpr const char* foreign_storage::ForeignTable::MANUAL_REFRESH_TIMING_TYPE = "MANUAL"

static

Definition at line 36 of file ForeignTable.h.

Referenced by CreateForeignTableCommand::setRefreshOptions(), and validate().

int64_t foreign_storage::ForeignTable::next_refresh_time {NULL_REFRESH_TIME}

Definition at line 40 of file ForeignTable.h.

Referenced by Catalog_Namespace::Catalog::createTable().

constexpr int foreign_storage::ForeignTable::NULL_REFRESH_TIME = -1

static

Definition at line 37 of file ForeignTable.h.

Referenced by foreign_storage::get_next_refresh_time(), and Catalog_Namespace::anonymous_namespace{Catalog.cpp}::get_next_refresh_time().

constexpr const char* foreign_storage::ForeignTable::REFRESH_INTERVAL_KEY = "REFRESH_INTERVAL"

static

Definition at line 31 of file ForeignTable.h.

Referenced by foreign_storage::get_next_refresh_time(), and validate().

constexpr const char* foreign_storage::ForeignTable::REFRESH_START_DATE_TIME_KEY = "REFRESH_START_DATE_TIME"

static

Definition at line 30 of file ForeignTable.h.

Referenced by foreign_storage::get_next_refresh_time(), and validate().

constexpr const char* foreign_storage::ForeignTable::REFRESH_TIMING_TYPE_KEY = "REFRESH_TIMING_TYPE"

static

Definition at line 29 of file ForeignTable.h.

Referenced by Catalog_Namespace::anonymous_namespace{Catalog.cpp}::get_next_refresh_time(), Catalog_Namespace::Catalog::getAllForeignTablesForRefresh(), CreateForeignTableCommand::setRefreshOptions(), and validate().

constexpr const char* foreign_storage::ForeignTable::REFRESH_UPDATE_TYPE_KEY = "REFRESH_UPDATE_TYPE"

static

Definition at line 32 of file ForeignTable.h.

Referenced by isAppendMode(), CreateForeignTableCommand::setRefreshOptions(), and validate().

constexpr const char* foreign_storage::ForeignTable::SCHEDULE_REFRESH_TIMING_TYPE = "SCHEDULED"

static

Definition at line 35 of file ForeignTable.h.

Referenced by Catalog_Namespace::anonymous_namespace{Catalog.cpp}::get_next_refresh_time(), Catalog_Namespace::Catalog::getAllForeignTablesForRefresh(), and validate().

constexpr std::array<const char*, 5> foreign_storage::ForeignTable::supported_options

static

Initial value:

{
      FRAGMENT_SIZE_KEY,
      REFRESH_TIMING_TYPE_KEY,
      REFRESH_START_DATE_TIME_KEY,
      REFRESH_INTERVAL_KEY,
      REFRESH_UPDATE_TYPE_KEY}

Definition at line 41 of file ForeignTable.h.

Referenced by foreign_storage::ParquetDataWrapper::validateOptions(), and validateRecognizedOption().

The documentation for this struct was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/Catalog/ForeignTable.h

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Detailed Description

Member Function Documentation

Member Data Documentation