ddl_utils Namespace Reference

Namespaces
	anonymous_namespace{DdlUtils.cpp}

Classes
class	SqlType
class	Encoding
class	FilePathWhitelist
class	FilePathBlacklist

Enumerations
enum	DataTransferType { DataTransferType::IMPORT = 1, DataTransferType::EXPORT }
enum	TableType { TableType::TABLE = 1, TableType::VIEW, TableType::FOREIGN_TABLE }

Functions
void	set_default_encoding (ColumnDescriptor &cd)
void	validate_and_set_fixed_encoding (ColumnDescriptor &cd, int encoding_size, const SqlType *column_type)
void	validate_and_set_dictionary_encoding (ColumnDescriptor &cd, int encoding_size)
void	validate_and_set_none_encoding (ColumnDescriptor &cd)
void	validate_and_set_sparse_encoding (ColumnDescriptor &cd, int encoding_size)
void	validate_and_set_compressed_encoding (ColumnDescriptor &cd, int encoding_size)
void	validate_and_set_date_encoding (ColumnDescriptor &cd, int encoding_size)
void	validate_and_set_encoding (ColumnDescriptor &cd, const Encoding *encoding, const SqlType *column_type)
void	validate_and_set_type (ColumnDescriptor &cd, SqlType *column_type)
void	validate_and_set_array_size (ColumnDescriptor &cd, const SqlType *column_type)
void	validate_and_set_default_value (ColumnDescriptor &cd, const std::string *default_value, bool not_null)
void	set_column_descriptor (const std::string &column_name, ColumnDescriptor &cd, SqlType *column_type, const bool not_null, const Encoding *encoding, const std::string *default_value)
void	set_default_table_attributes (const std::string &table_name, TableDescriptor &td, const int32_t column_count)
void	validate_non_duplicate_column (const std::string &column_name, std::unordered_set< std::string > &upper_column_names)
void	validate_non_reserved_keyword (const std::string &column_name)
void	validate_table_type (const TableDescriptor *td, const TableType expected_table_type, const std::string &command)
std::string	table_type_enum_to_string (const TableType table_type)
std::string	get_malformed_config_error_message (const std::string &config_key)
void	validate_expanded_file_path (const std::string &file_path, const std::vector< std::string > &whitelisted_root_paths)
std::vector< std::string >	get_expanded_file_paths (const std::string &file_path, const DataTransferType data_transfer_type)
void	validate_allowed_file_path (const std::string &file_path, const DataTransferType data_transfer_type, const bool allow_wildcards)
void	set_whitelisted_paths (const std::string &config_key, const std::string &config_value, std::vector< std::string > &whitelisted_paths)

Enumeration Type Documentation

enum ddl_utils::DataTransferType

strong

Enumerator
IMPORT
EXPORT

Definition at line 80 of file DdlUtils.h.

{ IMPORT = 1, EXPORT };

enum ddl_utils::TableType

strong

Enumerator
TABLE
VIEW
FOREIGN_TABLE

Definition at line 107 of file DdlUtils.h.

{ TABLE = 1, VIEW, FOREIGN_TABLE };

Function Documentation

std::vector<std::string> ddl_utils::get_expanded_file_paths	(	const std::string &	file_path,
		const DataTransferType	data_transfer_type
	)

Definition at line 761 of file DdlUtils.cpp.

References IMPORT, and shared::local_glob_filter_sort_files().

Referenced by validate_allowed_file_path().

                                               {
  std::vector<std::string> file_paths;
  if (data_transfer_type == DataTransferType::IMPORT) {
    file_paths = shared::local_glob_filter_sort_files(file_path, {});
  } else {
    std::string path;
    if (!boost::filesystem::exists(file_path)) {
      // For exports, it is possible to provide a path to a new (nonexistent) file. In
      // this case, validate using the parent path.
      path = boost::filesystem::path(file_path).parent_path().string();
      if (!boost::filesystem::exists(path)) {
        throw std::runtime_error{"File or directory \"" + file_path +
                                 "\" does not exist."};
      }
    } else {
      path = file_path;
    }
    file_paths = {path};
  }
  return file_paths;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string ddl_utils::get_malformed_config_error_message

(

const std::string &

config_key

)

Definition at line 738 of file DdlUtils.cpp.

Referenced by set_whitelisted_paths().

                                                                          {
  return "Configuration value for \"" + config_key +
         "\" is malformed. Value should be a list of paths with format: [ "
         "\"root-path-1\", \"root-path-2\", ... ]";
}

Here is the caller graph for this function:

void ddl_utils::set_column_descriptor	(	const std::string &	column_name,
		ColumnDescriptor &	cd,
		SqlType *	column_type,
		const bool	not_null,
		const Encoding *	encoding,
		const std::string *	default_value
	)

Definition at line 661 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, ColumnDescriptor::isSystemCol, ColumnDescriptor::isVirtualCol, SQLTypeInfo::set_notnull(), validate_and_set_array_size(), validate_and_set_default_value(), validate_and_set_encoding(), and validate_and_set_type().

Referenced by Parser::DDLStmt::setColumnDescriptor(), and CreateForeignTableCommand::setColumnDetails().

                                                           {
  cd.columnName = column_name;
  validate_and_set_type(cd, column_type);
  cd.columnType.set_notnull(not_null);
  validate_and_set_encoding(cd, encoding, column_type);
  validate_and_set_array_size(cd, column_type);
  cd.isSystemCol = false;
  cd.isVirtualCol = false;
  validate_and_set_default_value(cd, default_value, not_null);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::set_default_encoding

(

ColumnDescriptor &

cd

)

Definition at line 216 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, g_use_date_in_days_default_encoding, SQLTypeInfo::get_output_srid(), SQLTypeInfo::get_precision(), SQLTypeInfo::get_type(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_geometry(), SQLTypeInfo::is_string(), SQLTypeInfo::is_string_array(), kDATE, kENCODING_DATE_IN_DAYS, kENCODING_DICT, kENCODING_FIXED, kENCODING_GEOINT, kENCODING_NONE, sql_constants::kMaxNumericPrecision, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), and to_string().

Referenced by validate_and_set_encoding().

                                                {
  // Change default TEXT column behaviour to be DICT encoded
  if (cd.columnType.is_string() || cd.columnType.is_string_array()) {
    // default to 32-bits
    cd.columnType.set_compression(kENCODING_DICT);
    cd.columnType.set_comp_param(32);
  } else if (cd.columnType.is_decimal() && cd.columnType.get_precision() <= 4) {
    cd.columnType.set_compression(kENCODING_FIXED);
    cd.columnType.set_comp_param(16);
  } else if (cd.columnType.is_decimal() && cd.columnType.get_precision() <= 9) {
    cd.columnType.set_compression(kENCODING_FIXED);
    cd.columnType.set_comp_param(32);
  } else if (cd.columnType.is_decimal() &&
             cd.columnType.get_precision() > sql_constants::kMaxNumericPrecision) {
    throw std::runtime_error(cd.columnName + ": Precision too high, max " +
                             std::to_string(sql_constants::kMaxNumericPrecision) + ".");
  } else if (cd.columnType.is_geometry() && cd.columnType.get_output_srid() == 4326) {
    // default to GEOINT 32-bits
    cd.columnType.set_compression(kENCODING_GEOINT);
    cd.columnType.set_comp_param(32);
  } else if (cd.columnType.get_type() == kDATE && g_use_date_in_days_default_encoding) {
    // Days encoding for DATE
    cd.columnType.set_compression(kENCODING_DATE_IN_DAYS);
    cd.columnType.set_comp_param(0);
  } else {
    cd.columnType.set_compression(kENCODING_NONE);
    cd.columnType.set_comp_param(0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::set_default_table_attributes	(	const std::string &	table_name,
		TableDescriptor &	td,
		const int32_t	column_count
	)

Definition at line 677 of file DdlUtils.cpp.

References DEFAULT_FRAGMENT_ROWS, DEFAULT_MAX_CHUNK_SIZE, DEFAULT_MAX_ROWS, DEFAULT_PAGE_SIZE, TableDescriptor::fragmenter, TableDescriptor::fragPageSize, TableDescriptor::fragType, Fragmenter_Namespace::INSERT_ORDER, TableDescriptor::isView, TableDescriptor::maxChunkSize, TableDescriptor::maxFragRows, TableDescriptor::maxRows, TableDescriptor::nColumns, and TableDescriptor::tableName.

Referenced by Parser::CreateTableStmt::executeDryRun(), and CreateForeignTableCommand::setTableDetails().

                                                              {
  td.tableName = table_name;
  td.nColumns = column_count;
  td.isView = false;
  td.fragmenter = nullptr;
  td.fragType = Fragmenter_Namespace::FragmenterType::INSERT_ORDER;
  td.maxFragRows = DEFAULT_FRAGMENT_ROWS;
  td.maxChunkSize = DEFAULT_MAX_CHUNK_SIZE;
  td.fragPageSize = DEFAULT_PAGE_SIZE;
  td.maxRows = DEFAULT_MAX_ROWS;
}

Here is the caller graph for this function:

void ddl_utils::set_whitelisted_paths	(	const std::string &	config_key,
		const std::string &	config_value,
		std::vector< std::string > &	whitelisted_paths
	)

Definition at line 818 of file DdlUtils.cpp.

References get_malformed_config_error_message(), logger::INFO, LOG, and shared::printContainer().

Referenced by ddl_utils::FilePathWhitelist::initialize().

                                                                    {
  rapidjson::Document whitelisted_root_paths;
  whitelisted_root_paths.Parse(config_value);
  if (!whitelisted_root_paths.IsArray()) {
    throw std::runtime_error{get_malformed_config_error_message(config_key)};
  }
  for (const auto& root_path : whitelisted_root_paths.GetArray()) {
    if (!root_path.IsString()) {
      throw std::runtime_error{get_malformed_config_error_message(config_key)};
    }
    if (!boost::filesystem::exists(root_path.GetString())) {
      throw std::runtime_error{"Whitelisted root path \"" +
                               std::string{root_path.GetString()} + "\" does not exist."};
    }
    whitelisted_paths.emplace_back(
        boost::filesystem::canonical(root_path.GetString()).string());
  }
  LOG(INFO) << "Parsed " << config_key << ": "
            << shared::printContainer(whitelisted_paths);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string ddl_utils::table_type_enum_to_string

(

const TableType

table_type

)

Definition at line 725 of file DdlUtils.cpp.

References FOREIGN_TABLE, TABLE, and VIEW.

                                                                {
  if (table_type == ddl_utils::TableType::TABLE) {
    return "Table";
  }
  if (table_type == ddl_utils::TableType::FOREIGN_TABLE) {
    return "ForeignTable";
  }
  if (table_type == ddl_utils::TableType::VIEW) {
    return "View";
  }
  throw std::runtime_error{"Unexpected table type"};
}

void ddl_utils::validate_allowed_file_path	(	const std::string &	file_path,
		const DataTransferType	data_transfer_type,
		const bool	allow_wildcards = false
	)

Validates that the given file path is allowed. Validation entails ensuring that given path is not under a blacklisted root path and path is under a whitelisted path, if whitelisted paths have been configured. Also excludes the use of spaces and punctuation other than: . / _ + - = :

Parameters

file_path	- file path to validate
data_transfer_type	- enum indicating whether validation is for an import or export use case
allow_wildcards	- bool indicating if wildcards are allowed

Definition at line 785 of file DdlUtils.cpp.

References get_expanded_file_paths(), ddl_utils::FilePathBlacklist::isBlacklistedPath(), and ddl_utils::FilePathWhitelist::validateWhitelistedFilePath().

Referenced by TableArchiver::dumpTable(), Parser::CopyTableStmt::execute(), Parser::ExportQueryStmt::execute(), TableArchiver::restoreTable(), anonymous_namespace{TableArchiver.cpp}::simple_file_cat(), anonymous_namespace{DBHandler.cpp}::validate_import_file_path_if_local(), and foreign_storage::AbstractFileStorageDataWrapper::validateFilePath().

                                                            {
  // Reject any punctuation characters except for a few safe ones.
  // Some punctuation characters present a security risk when passed
  // to subprocesses. Don't change this without a security review.
  static const std::string safe_punctuation{"./_+-=:~"};
  for (const auto& ch : file_path) {
    if (std::ispunct(ch) && safe_punctuation.find(ch) == std::string::npos &&
        !(allow_wildcards && ch == '*')) {
      throw std::runtime_error(std::string("Punctuation \"") + ch +
                               "\" is not allowed in file path: " + file_path);
    }
  }

  // Enforce our whitelist and blacklist for file paths.
  const auto& expanded_file_paths =
      get_expanded_file_paths(file_path, data_transfer_type);
  for (const auto& path : expanded_file_paths) {
    if (FilePathBlacklist::isBlacklistedPath(path)) {
      const auto& canonical_file_path = boost::filesystem::canonical(file_path);
      if (canonical_file_path == boost::filesystem::absolute(file_path)) {
        throw std::runtime_error{"Access to file or directory path \"" + file_path +
                                 "\" is not allowed."};
      }
      throw std::runtime_error{"Access to file or directory path \"" + file_path +
                               "\" (resolved to \"" + canonical_file_path.string() +
                               "\") is not allowed."};
    }
  }
  FilePathWhitelist::validateWhitelistedFilePath(expanded_file_paths, data_transfer_type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_array_size	(	ColumnDescriptor &	cd,
		const SqlType *	column_type
	)

Definition at line 496 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, ddl_utils::SqlType::get_array_size(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_elem_type(), ddl_utils::SqlType::get_is_array(), SQLTypeInfo::get_size(), SQLTypeInfo::is_string_array(), kENCODING_DICT, SQLTypeInfo::set_fixed_size(), and SQLTypeInfo::set_size().

Referenced by set_column_descriptor().

                                                                                   {
  if (cd.columnType.is_string_array() &&
      cd.columnType.get_compression() != kENCODING_DICT) {
    throw std::runtime_error(
        cd.columnName +
        ": Array of strings must be dictionary encoded. Specify ENCODING DICT");
  }

  if (column_type->get_is_array()) {
    int s = -1;
    auto array_size = column_type->get_array_size();
    if (array_size > 0) {
      auto sti = cd.columnType.get_elem_type();
      s = array_size * sti.get_size();
      if (s <= 0) {
        throw std::runtime_error(cd.columnName + ": Unexpected fixed length array size");
      }
    }
    cd.columnType.set_size(s);

  } else {
    cd.columnType.set_fixed_size();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_compressed_encoding	(	ColumnDescriptor &	cd,
		int	encoding_size
	)

Definition at line 398 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, SQLTypeInfo::get_output_srid(), SQLTypeInfo::is_geometry(), kENCODING_GEOINT, SQLTypeInfo::set_comp_param(), and SQLTypeInfo::set_compression().

Referenced by validate_and_set_encoding().

                                                                                   {
  if (!cd.columnType.is_geometry() || cd.columnType.get_output_srid() != 4326) {
    throw std::runtime_error(
        cd.columnName + ": COMPRESSED encoding is only supported on WGS84 geo columns.");
  }
  int comp_param;
  if (encoding_size == 0) {
    comp_param = 32;  // default to 32-bits
  } else {
    comp_param = encoding_size;
  }
  if (comp_param != 32) {
    throw std::runtime_error(cd.columnName +
                             ": only 32-bit COMPRESSED geo encoding is supported");
  }
  // encoding longitude/latitude as integers
  cd.columnType.set_compression(kENCODING_GEOINT);
  cd.columnType.set_comp_param(comp_param);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_date_encoding	(	ColumnDescriptor &	cd,
		int	encoding_size
	)

Definition at line 418 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), kARRAY, kDATE, kENCODING_DATE_IN_DAYS, SQLTypeInfo::set_comp_param(), and SQLTypeInfo::set_compression().

Referenced by validate_and_set_encoding().

                                                                             {
  // days encoding for dates
  if (cd.columnType.get_type() == kARRAY && cd.columnType.get_subtype() == kDATE) {
    throw std::runtime_error(cd.columnName +
                             ": Cannot apply days encoding to date array.");
  }
  if (cd.columnType.get_type() != kDATE) {
    throw std::runtime_error(cd.columnName +
                             ": Days encoding is only supported for DATE columns.");
  }
  if (encoding_size != 32 && encoding_size != 16) {
    throw std::runtime_error(cd.columnName +
                             ": Compression parameter for Days encoding on "
                             "DATE must be 16 or 32.");
  }
  cd.columnType.set_compression(kENCODING_DATE_IN_DAYS);
  cd.columnType.set_comp_param((encoding_size == 16) ? 16 : 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_default_value	(	ColumnDescriptor &	cd,
		const std::string *	default_value,
		bool	not_null
	)

Definition at line 640 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, ColumnDescriptor::default_value, SQLTypeInfo::is_geometry(), to_upper(), and ddl_utils::anonymous_namespace{DdlUtils.cpp}::validate_literal().

Referenced by set_column_descriptor().

                                                   {
  bool is_null_literal =
      default_value && ((to_upper(*default_value) == "NULL") ||
                        (cd.columnType.is_geometry() && default_value->empty()));
  if (not_null && (is_null_literal)) {
    throw std::runtime_error(cd.columnName +
                             ": cannot set default value to NULL for "
                             "NOT NULL column");
  }
  if (!default_value || is_null_literal) {
    cd.default_value = std::nullopt;
    return;
  }
  const auto& column_type = cd.columnType;
  const auto& val = *default_value;
  validate_literal(val, column_type, cd.columnName);
  cd.default_value = std::make_optional(*default_value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_dictionary_encoding	(	ColumnDescriptor &	cd,
		int	encoding_size
	)

Definition at line 344 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, SQLTypeInfo::is_string(), SQLTypeInfo::is_string_array(), kENCODING_DICT, SQLTypeInfo::set_comp_param(), and SQLTypeInfo::set_compression().

Referenced by validate_and_set_encoding().

                                                                                   {
  if (!cd.columnType.is_string() && !cd.columnType.is_string_array()) {
    throw std::runtime_error(
        cd.columnName +
        ": Dictionary encoding is only supported on string or string array columns.");
  }
  int comp_param;
  if (encoding_size == 0) {
    comp_param = 32;  // default to 32-bits
  } else {
    comp_param = encoding_size;
  }
  if (cd.columnType.is_string_array() && comp_param != 32) {
    throw std::runtime_error(cd.columnName +
                             ": Compression parameter for string arrays must be 32");
  }
  if (comp_param != 8 && comp_param != 16 && comp_param != 32) {
    throw std::runtime_error(
        cd.columnName +
        ": Compression parameter for Dictionary encoding must be 8 or 16 or 32.");
  }
  // dictionary encoding
  cd.columnType.set_compression(kENCODING_DICT);
  cd.columnType.set_comp_param(comp_param);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_encoding	(	ColumnDescriptor &	cd,
		const Encoding *	encoding,
		const SqlType *	column_type
	)

Definition at line 437 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, ddl_utils::Encoding::get_encoding_name(), ddl_utils::Encoding::get_encoding_param(), kENCODING_DIFF, kENCODING_RL, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), set_default_encoding(), validate_and_set_compressed_encoding(), validate_and_set_date_encoding(), validate_and_set_dictionary_encoding(), validate_and_set_fixed_encoding(), validate_and_set_none_encoding(), and validate_and_set_sparse_encoding().

Referenced by set_column_descriptor().

                                                           {
  if (encoding == nullptr) {
    set_default_encoding(cd);
  } else {
    const std::string& comp = *encoding->get_encoding_name();
    if (boost::iequals(comp, "fixed")) {
      validate_and_set_fixed_encoding(cd, encoding->get_encoding_param(), column_type);
    } else if (boost::iequals(comp, "rl")) {
      // run length encoding
      cd.columnType.set_compression(kENCODING_RL);
      cd.columnType.set_comp_param(0);
      // throw std::runtime_error("RL(Run Length) encoding not supported yet.");
    } else if (boost::iequals(comp, "diff")) {
      // differential encoding
      cd.columnType.set_compression(kENCODING_DIFF);
      cd.columnType.set_comp_param(0);
      // throw std::runtime_error("DIFF(differential) encoding not supported yet.");
    } else if (boost::iequals(comp, "dict")) {
      validate_and_set_dictionary_encoding(cd, encoding->get_encoding_param());
    } else if (boost::iequals(comp, "NONE")) {
      validate_and_set_none_encoding(cd);
    } else if (boost::iequals(comp, "sparse")) {
      validate_and_set_sparse_encoding(cd, encoding->get_encoding_param());
    } else if (boost::iequals(comp, "compressed")) {
      validate_and_set_compressed_encoding(cd, encoding->get_encoding_param());
    } else if (boost::iequals(comp, "days")) {
      validate_and_set_date_encoding(cd, encoding->get_encoding_param());
    } else {
      throw std::runtime_error(cd.columnName + ": Invalid column compression scheme " +
                               comp);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_fixed_encoding	(	ColumnDescriptor &	cd,
		int	encoding_size,
		const SqlType *	column_type
	)

Definition at line 246 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, SQLTypeInfo::get_precision(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), is_datetime(), SQLTypeInfo::is_high_precision_timestamp(), IS_INTEGER, kARRAY, kBIGINT, kDATE, kDECIMAL, kENCODING_DATE_IN_DAYS, kENCODING_FIXED, kINT, kNUMERIC, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), ddl_utils::SqlType::to_string(), and run_benchmark_import::type.

Referenced by validate_and_set_encoding().

                                                                 {
  auto type = cd.columnType.get_type();
  // fixed-bits encoding
  if (type == kARRAY) {
    type = cd.columnType.get_subtype();
    switch (type) {
      case kTINYINT:
      case kSMALLINT:
      case kINT:
      case kBIGINT:
      case kDATE:
        throw std::runtime_error(cd.columnName + ": Cannot apply FIXED encoding to " +
                                 column_type->to_string() + " type array.");
        break;
      default:
        break;
    }
  }

  if (!IS_INTEGER(type) && !is_datetime(type) &&
      !(type == kDECIMAL || type == kNUMERIC)) {
    throw std::runtime_error(
        cd.columnName +
        ": Fixed encoding is only supported for integer or time columns.");
  }

  switch (type) {
    case kSMALLINT:
      if (encoding_size != 8) {
        throw std::runtime_error(
            cd.columnName +
            ": Compression parameter for Fixed encoding on SMALLINT must be 8.");
      }
      break;
    case kINT:
      if (encoding_size != 8 && encoding_size != 16) {
        throw std::runtime_error(
            cd.columnName +
            ": Compression parameter for Fixed encoding on INTEGER must be 8 or 16.");
      }
      break;
    case kBIGINT:
      if (encoding_size != 8 && encoding_size != 16 && encoding_size != 32) {
        throw std::runtime_error(cd.columnName +
                                 ": Compression parameter for Fixed encoding on "
                                 "BIGINT must be 8 or 16 or 32.");
      }
      break;
    case kTIMESTAMP:
    case kTIME:
      if (encoding_size != 32) {
        throw std::runtime_error(cd.columnName +
                                 ": Compression parameter for Fixed encoding on "
                                 "TIME or TIMESTAMP must be 32.");
      } else if (cd.columnType.is_high_precision_timestamp()) {
        throw std::runtime_error("Fixed encoding is not supported for TIMESTAMP(3|6|9).");
      }
      break;
    case kDECIMAL:
    case kNUMERIC:
      if (encoding_size != 32 && encoding_size != 16) {
        throw std::runtime_error(cd.columnName +
                                 ": Compression parameter for Fixed encoding on "
                                 "DECIMAL must be 16 or 32.");
      }

      if (encoding_size == 32 && cd.columnType.get_precision() > 9) {
        throw std::runtime_error(cd.columnName +
                                 ": Precision too high for Fixed(32) encoding, max 9.");
      }

      if (encoding_size == 16 && cd.columnType.get_precision() > 4) {
        throw std::runtime_error(cd.columnName +
                                 ": Precision too high for Fixed(16) encoding, max 4.");
      }
      break;
    case kDATE:
      if (encoding_size != 32 && encoding_size != 16) {
        throw std::runtime_error(cd.columnName +
                                 ": Compression parameter for Fixed encoding on "
                                 "DATE must be 16 or 32.");
      }
      break;
    default:
      throw std::runtime_error(cd.columnName + ": Cannot apply FIXED encoding to " +
                               column_type->to_string());
  }
  if (type == kDATE) {
    cd.columnType.set_compression(kENCODING_DATE_IN_DAYS);
    cd.columnType.set_comp_param(16);
  } else {
    cd.columnType.set_compression(kENCODING_FIXED);
    cd.columnType.set_comp_param(encoding_size);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_none_encoding

(

ColumnDescriptor &

cd

)

Definition at line 370 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, SQLTypeInfo::is_geometry(), SQLTypeInfo::is_string(), SQLTypeInfo::is_string_array(), kENCODING_NONE, SQLTypeInfo::set_comp_param(), and SQLTypeInfo::set_compression().

Referenced by validate_and_set_encoding().

                                                          {
  if (!cd.columnType.is_string() && !cd.columnType.is_string_array() &&
      !cd.columnType.is_geometry()) {
    throw std::runtime_error(
        cd.columnName +
        ": None encoding is only supported on string, string array, or geo columns.");
  }
  cd.columnType.set_compression(kENCODING_NONE);
  cd.columnType.set_comp_param(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_sparse_encoding	(	ColumnDescriptor &	cd,
		int	encoding_size
	)

Definition at line 381 of file DdlUtils.cpp.

References ColumnDescriptor::columnName, ColumnDescriptor::columnType, SQLTypeInfo::get_notnull(), kENCODING_SPARSE, SQLTypeInfo::set_comp_param(), and SQLTypeInfo::set_compression().

Referenced by validate_and_set_encoding().

                                                                               {
  // sparse column encoding with mostly NULL values
  if (cd.columnType.get_notnull()) {
    throw std::runtime_error(cd.columnName +
                             ": Cannot do sparse column encoding on a NOT NULL column.");
  }
  if (encoding_size == 0 || encoding_size % 8 != 0 || encoding_size > 48) {
    throw std::runtime_error(
        cd.columnName +
        "Must specify number of bits as 8, 16, 24, 32 or 48 as the parameter to "
        "sparse-column encoding.");
  }
  cd.columnType.set_compression(kENCODING_SPARSE);
  cd.columnType.set_comp_param(encoding_size);
  // throw std::runtime_error("SPARSE encoding not supported yet.");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_and_set_type	(	ColumnDescriptor &	cd,
		SqlType *	column_type
	)

Definition at line 473 of file DdlUtils.cpp.

References ddl_utils::SqlType::check_type(), ColumnDescriptor::columnType, ddl_utils::SqlType::get_is_array(), ddl_utils::SqlType::get_param1(), ddl_utils::SqlType::get_param2(), ddl_utils::SqlType::get_type(), IS_GEO, kARRAY, kGEOMETRY, SQLTypeInfo::set_dimension(), SQLTypeInfo::set_input_srid(), SQLTypeInfo::set_output_srid(), SQLTypeInfo::set_scale(), SQLTypeInfo::set_subtype(), and SQLTypeInfo::set_type().

Referenced by set_column_descriptor().

                                                                       {
  column_type->check_type();

  if (column_type->get_type() == kGEOMETRY) {
    throw std::runtime_error("Unsupported type \"GEOMETRY\" specified.");
  }

  if (column_type->get_is_array()) {
    cd.columnType.set_type(kARRAY);
    cd.columnType.set_subtype(column_type->get_type());
  } else {
    cd.columnType.set_type(column_type->get_type());
  }
  if (IS_GEO(column_type->get_type())) {
    cd.columnType.set_subtype(static_cast<SQLTypes>(column_type->get_param1()));
    cd.columnType.set_input_srid(column_type->get_param2());
    cd.columnType.set_output_srid(column_type->get_param2());
  } else {
    cd.columnType.set_dimension(column_type->get_param1());
    cd.columnType.set_scale(column_type->get_param2());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ddl_utils::validate_expanded_file_path	(	const std::string &	file_path,
		const std::vector< std::string > &	whitelisted_root_paths
	)

Definition at line 744 of file DdlUtils.cpp.

Referenced by ddl_utils::FilePathWhitelist::validateWhitelistedFilePath().

                                                                                     {
  const auto& canonical_file_path = boost::filesystem::canonical(file_path);
  for (const auto& root_path : whitelisted_root_paths) {
    if (boost::istarts_with(canonical_file_path.string(), root_path)) {
      return;
    }
  }
  if (canonical_file_path == boost::filesystem::absolute(file_path)) {
    throw std::runtime_error{"File or directory path \"" + file_path +
                             "\" is not whitelisted."};
  }
  throw std::runtime_error{"File or directory path \"" + file_path +
                           "\" (resolved to \"" + canonical_file_path.string() +
                           "\") is not whitelisted."};
}

Here is the caller graph for this function:

void ddl_utils::validate_non_duplicate_column	(	const std::string &	column_name,
		std::unordered_set< std::string > &	upper_column_names
	)

Definition at line 691 of file DdlUtils.cpp.

Referenced by Parser::CreateTableStmt::executeDryRun(), and CreateForeignTableCommand::setColumnDetails().

                                                                                    {
  const auto upper_column_name = boost::to_upper_copy<std::string>(column_name);
  const auto insert_it = upper_column_names.insert(upper_column_name);
  if (!insert_it.second) {
    throw std::runtime_error("Column '" + column_name + "' defined more than once");
  }
}

Here is the caller graph for this function:

void ddl_utils::validate_non_reserved_keyword

(

const std::string &

column_name

)

Definition at line 700 of file DdlUtils.cpp.

References reserved_keywords.

Referenced by CreateForeignTableCommand::setColumnDetails().

                                                                 {
  const auto upper_column_name = boost::to_upper_copy<std::string>(column_name);
  if (reserved_keywords.find(upper_column_name) != reserved_keywords.end()) {
    throw std::runtime_error("Cannot create column with reserved keyword '" +
                             column_name + "'");
  }
}

Here is the caller graph for this function:

void ddl_utils::validate_table_type	(	const TableDescriptor *	td,
		const TableType	expected_table_type,
		const std::string &	command
	)

Definition at line 708 of file DdlUtils.cpp.

References StorageType::FOREIGN_TABLE, FOREIGN_TABLE, TableDescriptor::isView, TableDescriptor::storageType, TABLE, TableDescriptor::tableName, and VIEW.

Referenced by Parser::AddColumnStmt::check_executable(), DropForeignTableCommand::execute(), AlterForeignTableCommand::execute(), Parser::DropTableStmt::execute(), Parser::RenameColumnStmt::execute(), Parser::DropColumnStmt::execute(), and Parser::DropViewStmt::execute().

                                                   {
  if (td->isView) {
    if (expected_table_type != TableType::VIEW) {
      throw std::runtime_error(td->tableName + " is a view. Use " + command + " VIEW.");
    }
  } else if (td->storageType == StorageType::FOREIGN_TABLE) {
    if (expected_table_type != TableType::FOREIGN_TABLE) {
      throw std::runtime_error(td->tableName + " is a foreign table. Use " + command +
                               " FOREIGN TABLE.");
    }
  } else if (expected_table_type != TableType::TABLE) {
    throw std::runtime_error(td->tableName + " is a table. Use " + command + " TABLE.");
  }
}

Here is the caller graph for this function: