shared Namespace Reference

Namespaces
	anonymous_namespace{file_path_util.cpp}

Classes
class	FileNotFoundException
class	NoRegexFilterMatchException
struct	FilePathOptions
class	FileOrderBase
class	FileOrderLocal
struct	PrintContainer
struct	is_std_container
struct	is_std_container< std::deque< T, A > >
struct	is_std_container< std::list< T, A > >
struct	is_std_container< std::set< T, A > >
struct	is_std_container< std::unordered_set< T, A > >
struct	is_std_container< std::vector< T, A > >
struct	DivUMod

Typedefs
using	LocalFileComparator = std::function< bool(const std::string &, const std::string &)>

Functions
std::string	decode_base64_uri (const std::string &data, bool trim_nulls)
std::string	decode_base64 (const std::string &val, bool trim_nulls)
std::string	decode_base64 (const std::string &val)
static std::string	encode_base64 (const std::string &val)
void	validate_sort_options (const FilePathOptions &options)
std::vector< std::string >	local_glob_filter_sort_files (const std::string &file_path, const FilePathOptions &options, const bool recurse)
bool	file_or_glob_path_exists (const std::string &path)
std::set< std::string >	check_for_rolled_off_file_paths (const std::vector< std::string > &all_file_paths, std::vector< std::string > &processed_file_paths)
void	throw_file_not_found (const std::string &file_path)
void	throw_no_filter_match (const std::string &pattern)
bool	is_compressed_mime_type (const std::string &mime_type)
bool	is_compressed_file_extension (const std::string &location)
void	execute_over_contiguous_indices (const std::vector< size_t > &indices, std::function< void(const size_t, const size_t)> to_execute)
bool	isPowOfTwo (unsigned n)
unsigned	getExpOfTwo (unsigned n)
size_t	formatDate (char *buf, size_t const max, int64_t const unixtime)
size_t	formatDateTime (char *buf, size_t const max, int64_t const timestamp, int const dimension, bool use_iso_format)
size_t	formatHMS (char *buf, size_t const max, int64_t const unixtime)
std::string	convert_temporal_to_iso_format (const SQLTypeInfo &type_info, int64_t unix_time)
template<typename K , typename V , typename comp >
V &	get_from_map (std::map< K, V, comp > &map, const K &key)
template<typename K , typename V , typename comp >
const V &	get_from_map (const std::map< K, V, comp > &map, const K &key)
template<typename T >
size_t	append_move (std::vector< T > &destination, std::vector< T > &&source)
template<typename... Ts, typename T >
bool	dynamic_castable_to_any (T const *ptr)
template<typename CONTAINER >
PrintContainer< CONTAINER >	printContainer (CONTAINER &container)
template<typename OSTREAM , typename CONTAINER >
OSTREAM &	operator<< (OSTREAM &os, PrintContainer< CONTAINER > pc)
DivUMod	divUMod (int64_t num, int64_t den)
uint64_t	unsignedMod (int64_t num, int64_t den)
template<typename T , typename U >
bool	contains (const T &container, const U &element)
template<typename... COEFFICIENTS>
DEVICE constexpr double	horner (double const x, double const c0, COEFFICIENTS...c)
DEVICE double	fastAtanh (double const x)
DEVICE double	fastCos (double const x)
DEVICE double	fastCosh (double const x)
DEVICE double	fastSin (double const x)
DEVICE double	fastSinh (double const x)
template<int... values, typename T >
bool	is_any (T &&value)
template<typename T , size_t N>
constexpr std::array< T, N >	powersOf (T const a)
template<size_t N>
constexpr std::array< double, N >	inversePowersOf (double const a)
double	power10 (unsigned const x)
double	power10inv (unsigned const x)
template<typename TO , typename FROM >
TO	reinterpret_bits (FROM const from)
template<typename TO , typename FROM >
TO	bit_cast (FROM &&from)
template<typename... STR>
constexpr std::array < std::string_view, sizeof...(STR)>	string_view_array (STR &&...str)
template<typename OUTPUT , typename INPUT , typename FUNC >
OUTPUT	transform (INPUT const &input, FUNC const &func)
unsigned	ceil_div (unsigned const dividend, unsigned const divisor)
template<class T , std::size_t... N>
constexpr T	bswap_impl (T i, std::index_sequence< N...>)
template<class T , class U = typename std::make_unsigned<T>::type>
constexpr U	bswap (T i)
template<class T >
constexpr T	byteswap (T n) noexcept
constexpr auto	heavyai_htons (std::uint16_t h)
constexpr auto	heavyai_htonl (std::uint32_t h)
constexpr auto	heavyai_htonll (std::uint64_t h)
constexpr auto	heavyai_ntohs (std::uint16_t n)
constexpr auto	heavyai_ntohl (std::uint32_t n)
constexpr auto	heavyai_ntohll (std::uint64_t n)
std::shared_ptr < apache::thrift::TConfiguration >	default_tconfig ()

Variables
const std::string	FILE_SORT_ORDER_BY_KEY = "FILE_SORT_ORDER_BY"
const std::string	FILE_SORT_REGEX_KEY = "FILE_SORT_REGEX"
const std::string	PATHNAME_ORDER_TYPE = "PATHNAME"
const std::string	DATE_MODIFIED_ORDER_TYPE = "DATE_MODIFIED"
const std::string	REGEX_ORDER_TYPE = "REGEX"
const std::string	REGEX_DATE_ORDER_TYPE = "REGEX_DATE"
const std::string	REGEX_NUMBER_ORDER_TYPE = "REGEX_NUMBER"
const std::array< std::string, 5 >	supported_file_sort_order_types
const std::array< std::string, 2 >	non_regex_sort_order_types
const std::array< std::string, 3 >	regex_sort_order_types
const std::function< bool(const std::string &, const std::string &)>	common_regex_date_comp_
const std::function< bool(const std::string &, const std::string &)>	common_regex_number_comp_
const std::string	kSystemCatalogName = "system_catalog"
const std::string	kDefaultDbName = "heavyai"
const std::string	kRootUsername = "admin"
const int	kRootUserId = 0
const std::string	kRootUserIdStr = "0"
const std::string	kDefaultRootPasswd = "HyperInteractive"
const int32_t	kTempUserIdRange = 1000000000
const std::string	kInfoSchemaDbName = "information_schema"
const std::string	kInfoSchemaMigrationName = "information_schema_db_created"
const std::string	kDefaultExportDirName = "export"
const std::string	kDefaultImportDirName = "import"
const std::string	kDefaultDiskCacheDirName = "disk_cache"
const std::string	kDefaultKeyFileName = "heavyai.pem"
const std::string	kDefaultKeyStoreDirName = "key_store"
const std::string	kDefaultLogDirName = "log"
const std::string	kCatalogDirectoryName = "catalogs"
const std::string	kDataDirectoryName = "data"
const std::string	kLockfilesDirectoryName = "lockfiles"
const std::string	kDefaultLicenseFileName = "heavyai.license"

Typedef Documentation

using shared::LocalFileComparator = typedef std::function<bool(const std::string&, const std::string&)>

Definition at line 42 of file file_path_util.h.

Function Documentation

template<typename T >

size_t shared::append_move	(	std::vector< T > &	destination,
		std::vector< T > &&	source
	)

Definition at line 77 of file misc.h.

Referenced by RelAlgExecutor::createUnionWorkUnit().

                                                                     {
  if (source.empty()) {
    return 0;
  } else if (destination.empty()) {
    destination = std::move(source);
    return destination.size();
  } else {
    size_t const source_size = source.size();
    destination.reserve(destination.size() + source_size);
    std::move(std::begin(source), std::end(source), std::back_inserter(destination));
    return source_size;
  }
}

Here is the caller graph for this function:

template<typename TO , typename FROM >

TO shared::bit_cast ( FROM &&  from )

inline

Definition at line 298 of file misc.h.

Referenced by TargetExprCodegen::codegen(), GroupByAndAggregate::codegenAggColumnPtr(), CodeGenerator::codegenHoistedConstantsLoads(), GroupByAndAggregate::getAdditionalLiteral(), and ResultSet::isLessThan().

                                {
#if 202002L <= __cplusplus  // C++20
  if constexpr (sizeof(TO) <= sizeof(FROM)) {
    return std::bit_cast<TO>(std::forward<FROM>(from));
  } else {
    TO to{0};  // std::bit_cast() has the undesirable feature of indeterminate bits.
    memcpy(&to, &from, sizeof(FROM));
    return to;
  }
#else
  TO to{0};
  memcpy(&to, &from, sizeof(TO) < sizeof(FROM) ? sizeof(TO) : sizeof(FROM));
  return to;
#endif
}

Here is the caller graph for this function:

template<class T , class U = typename std::make_unsigned<T>::type>

constexpr U shared::bswap

(

T

i

)

Definition at line 398 of file misc.h.

Referenced by byteswap().

                       {
  return bswap_impl<U>(i, std::make_index_sequence<sizeof(T)>{});
}

Here is the caller graph for this function:

template<class T , std::size_t... N>

constexpr T shared::bswap_impl	(	T	i,
		std::index_sequence< N...>
	)

Definition at line 392 of file misc.h.

References anonymous_namespace{Utm.h}::N, and heavydb.dtypes::T.

                                                     {
  return ((((i >> (N * CHAR_BIT)) & (T)(unsigned char)(-1))
           << ((sizeof(T) - 1 - N) * CHAR_BIT)) |
          ...);
};

template<class T >

constexpr T shared::byteswap ( T  n )

noexcept

Definition at line 402 of file misc.h.

References bswap(), and anonymous_namespace{Utm.h}::n.

Referenced by heavyai_htonl(), heavyai_htonll(), heavyai_htons(), heavyai_ntohl(), heavyai_ntohll(), and heavyai_ntohs().

                                   {
  return bswap(n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned shared::ceil_div ( unsigned const  dividend, unsigned const  divisor  )

inline

Definition at line 329 of file misc.h.

Referenced by Executor::numBlocksPerMP().

                                                                          {
  return (dividend + (divisor - 1)) / divisor;
}

Here is the caller graph for this function:

std::set< std::string > shared::check_for_rolled_off_file_paths	(	const std::vector< std::string > &	all_file_paths,
		std::vector< std::string > &	processed_file_paths
	)

Definition at line 178 of file file_path_util.cpp.

Referenced by foreign_storage::MultiFileReader::checkForRolledOffFiles(), and foreign_storage::ParquetDataWrapper::fetchChunkMetadata().

                                                {
  std::set<std::string> rolled_off_file_paths;
  if (all_file_paths.empty()) {
    // An empty all_file_paths vector implies that all files have been rolled off
    rolled_off_file_paths.insert(processed_file_paths.begin(),
                                 processed_file_paths.end());
  } else {
    auto roll_off_end_it = std::find(
        processed_file_paths.begin(), processed_file_paths.end(), all_file_paths[0]);
    for (auto it = processed_file_paths.begin(); it != roll_off_end_it; it++) {
      rolled_off_file_paths.emplace(*it);
    }
  }
  if (!rolled_off_file_paths.empty()) {
    processed_file_paths.erase(
        processed_file_paths.begin(),
        processed_file_paths.begin() + rolled_off_file_paths.size());
  }
  return rolled_off_file_paths;
}

Here is the caller graph for this function:

template<typename T , typename U >

bool shared::contains ( const T &  container, const U &  element  )

inline

Definition at line 195 of file misc.h.

Referenced by foreign_storage::LocalMultiFileReader::checkForMoreRows(), com.mapd.calcite.parser.ExtTableFunctionTypeChecker::checkOperandTypes(), com.mapd.calcite.parser.ExtTableFunctionTypeChecker::doesOperandTypeMatch(), RefreshForeignTablesCommand::execute(), foreign_storage::ParquetDataWrapper::fetchChunkMetadata(), Catalog_Namespace::Catalog::getForeignServersForUser(), TableOptimizer::getFragmentIndexes(), is_compressed_file_extension(), is_compressed_mime_type(), Grantee::reassignObjectOwners(), Catalog_Namespace::SysCatalog::reassignObjectOwners(), Catalog_Namespace::Catalog::reassignOwners(), foreign_storage::refresh_foreign_table(), Catalog_Namespace::Catalog::updateForeignTablesInMapUnlocked(), foreign_storage::ParquetDataWrapper::updateMetadataForRolledOffFiles(), foreign_storage::AbstractTextFileDataWrapper::updateRolledOffChunks(), TableOptimizer::vacuumFragments(), validate_sort_options(), foreign_storage::ForeignDataWrapperFactory::validateDataWrapperType(), and foreign_storage::AbstractFileStorageDataWrapper::validateServerOptions().

                                                           {
  if (std::find(container.begin(), container.end(), element) == container.end()) {
    return false;
  } else {
    return true;
  }
}

Here is the caller graph for this function:

std::string shared::convert_temporal_to_iso_format	(	const SQLTypeInfo &	type_info,
		int64_t	unix_time
	)

Definition at line 109 of file misc.cpp.

References CHECK_EQ, CHECK_GT, formatDate(), formatDateTime(), formatHMS(), SQLTypeInfo::get_precision(), SQLTypeInfo::get_type(), kDATE, kTIME, kTIMESTAMP, SQLTypeInfo::toString(), and UNREACHABLE.

Referenced by import_export::QueryExporterCSV::exportResults(), anonymous_namespace{DBHandler.cpp}::get_refresh_info(), import_export::anonymous_namespace{QueryExporterGDAL.cpp}::insert_array_column(), import_export::anonymous_namespace{QueryExporterGDAL.cpp}::insert_scalar_column(), and import_export::anonymous_namespace{QueryExporterCSV.cpp}::target_value_to_string().

                                                              {
  std::string iso_str;
  if (type_info.get_type() == kTIME) {
    // Set a buffer size that can contain HH:MM:SS
    iso_str.resize(8);
    const auto len = shared::formatHMS(iso_str.data(), iso_str.length() + 1, unix_time);
    CHECK_EQ(len, iso_str.length());
  } else if (type_info.get_type() == kDATE) {
    // Set a buffer size that can contain YYYYYYYYYYYY-mm-dd (int64_t can represent up to
    // 12 digit years)
    iso_str.resize(18);
    const size_t len =
        shared::formatDate(iso_str.data(), iso_str.length() + 1, unix_time);
    CHECK_GT(len, static_cast<size_t>(0));
    iso_str.resize(len);
  } else if (type_info.get_type() == kTIMESTAMP) {
    auto precision = type_info.get_precision();
    // Set a buffer size that can contain the specified timestamp precision
    // YYYYYYYYYYYY-mm-dd(18) T(1) HH:MM:SS(8) .(precision?) nnnnnnnnn(precision) Z(1)
    // (int64_t can represent up to 12 digit years with seconds precision)
    iso_str.resize(18 + 1 + 8 + bool(precision) + precision + 1);
    const size_t len = shared::formatDateTime(
        iso_str.data(), iso_str.length() + 1, unix_time, precision, true);
    CHECK_GT(len, static_cast<size_t>(0));
    iso_str.resize(len);
  } else {
    UNREACHABLE() << "Unexpected column type: " << type_info.toString();
  }
  return iso_str;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string shared::decode_base64 ( const std::string &  val, bool  trim_nulls  )

inline

Definition at line 27 of file base64.h.

Referenced by decode_base64(), and decode_base64_uri().

                                                                      {
  // For some strings, signatature particualary it is important no to trim
  // '\0' characters
  using namespace boost::archive::iterators;
  using It = transform_width<binary_from_base64<std::string::const_iterator>, 8, 6>;

  if (!trim_nulls) {
    return std::string(It(val.begin()), It(val.end()));
  }
  return boost::algorithm::trim_right_copy_if(
      std::string(It(std::begin(val)), It(std::end(val))),
      [](char c) { return c == '\0'; });
}

Here is the caller graph for this function:

std::string shared::decode_base64 ( const std::string &  val )

inline

Definition at line 41 of file base64.h.

References decode_base64().

                                                     {
  return decode_base64(val, true);
}

Here is the call graph for this function:

std::string shared::decode_base64_uri	(	const std::string &	data,
		bool	trim_nulls
	)

Definition at line 21 of file base64.cpp.

References decode_base64(), and transform().

                                                                    {
  // Allocate a string large enough to hold exta '=' as padding
  std::string uri_dec;
  size_t data_len = data.length();
  // base64_uri encoding removes '=' padding at the end of the string.
  size_t padding = 4 - (data_len % 4);
  if (padding == 4) {
    padding = 0;
  }
  uri_dec.resize(data_len + padding);

  // base64_uri encoding replaces all '+' and '/' with '-' and '_' respectively.
  std::transform(
      data.begin(), data.end(), uri_dec.begin(), [](unsigned char c) -> unsigned char {
        switch (c) {
          case '-':
            return '+';
          case '_':
            return '/';
          default:
            return c;
        }
      });
  if (padding != 0) {
    uri_dec.replace(uri_dec.begin() + data_len, uri_dec.end(), padding, '=');
  }
  // in the case of a signature from a JWT trim_nulls should be false
  return decode_base64(uri_dec, trim_nulls);
}

Here is the call graph for this function:

std::shared_ptr<apache::thrift::TConfiguration> shared::default_tconfig ( )

inline

Definition at line 26 of file ThriftConfig.h.

Referenced by ThriftClientConnection::open_buffered_client_transport().

                                                                   {
  return std::make_shared<apache::thrift::TConfiguration>(
      std::numeric_limits<int32_t>::max());
}

Here is the caller graph for this function:

DivUMod shared::divUMod ( int64_t  num, int64_t  den  )

inline

Definition at line 176 of file misc.h.

References shared::DivUMod::quot.

Referenced by formatDate(), and formatDateTime().

                                                 {
  DivUMod div{num / den, num % den};
  if (div.rem < 0) {
    --div.quot;
    div.rem += den;
  }
  return div;
}

Here is the caller graph for this function:

template<typename... Ts, typename T >

bool shared::dynamic_castable_to_any

(

T const *

ptr

)

Definition at line 92 of file misc.h.

                                           {
  return (... || dynamic_cast<Ts const*>(ptr));
}

static std::string shared::encode_base64 ( const std::string &  val )

inlinestatic

Definition at line 45 of file base64.h.

                                                            {
  using namespace boost::archive::iterators;
  using It = base64_from_binary<transform_width<std::string::const_iterator, 6, 8>>;
  auto tmp = std::string(It(std::begin(val)), It(std::end(val)));
  return tmp.append((3 - val.size() % 3) % 3, '=');
}

void shared::execute_over_contiguous_indices	(	const std::vector< size_t > &	indices,
		std::function< void(const size_t, const size_t)>	to_execute
	)

Definition at line 22 of file Iteration.h.

Referenced by DateDaysEncoder< T, V >::appendEncodedDataAtIndices(), FixedLengthEncoder< T, V >::appendEncodedDataAtIndices(), and NoneEncoder< T >::appendEncodedDataAtIndices().

                                                              {
  size_t start_pos = 0;

  while (start_pos < indices.size()) {
    size_t end_pos = indices.size();
    for (size_t i = start_pos + 1; i < indices.size(); ++i) {
      if (indices[i] != indices[i - 1] + 1) {
        end_pos = i;
        break;
      }
    }
    to_execute(start_pos, end_pos);
    start_pos = end_pos;
  }
}

Here is the caller graph for this function:

DEVICE double shared::fastAtanh ( double const  x )

inline

Definition at line 215 of file misc.h.

References horner().

Referenced by Transform4326ToUTM::Transform4326ToUTM().

                                               {
  // Mathematica: CoefficientList[Normal@Series[ArcTanh[x],{x,0,16}],x] // InputForm
  return x * horner(x * x, 1, 1 / 3., 1 / 5., 1 / 7., 1 / 9., 1 / 11., 1 / 13., 1 / 15.);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE double shared::fastCos ( double const  x )

inline

Definition at line 221 of file misc.h.

References horner().

Referenced by Transform4326ToUTM::Transform4326ToUTM().

                                             {
  // Mathematica: CoefficientList[Normal@Series[Cos[x],{x,0,16}],x] // InputForm
  // clang-format off
  return horner(x * x, 1, -1/2., 1/24., -1/720., 1/40320., -1/3628800.,
                1/479001600., -1/87178291200., 1/20922789888000.);
  // clang-format on
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE double shared::fastCosh ( double const  x )

inline

Definition at line 230 of file misc.h.

References horner().

Referenced by Transform4326ToUTM::calculateY(), TransformUTMTo4326::calculateY(), and TransformUTMTo4326::TransformUTMTo4326().

                                              {
  // Mathematica: CoefficientList[Normal@Series[Cosh[x],{x,0,16}],x] // InputForm
  // clang-format off
  return horner(x * x, 1, 1/2., 1/24., 1/720., 1/40320., 1/3628800.,
                1/479001600., 1/87178291200., 1/20922789888000.);
  // clang-format on
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE double shared::fastSin ( double const  x )

inline

Definition at line 239 of file misc.h.

References horner().

Referenced by Transform4326ToUTM::Transform4326ToUTM().

                                             {
  // Mathematica: CoefficientList[Normal@Series[Sin[x],{x,0,16}],x] // InputForm
  // clang-format off
  return x * horner(x * x, 1, -1/6., 1/120., -1/5040., 1/362880.,
                    -1/39916800., 1/6227020800., -1/1307674368000.);
  // clang-format on
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEVICE double shared::fastSinh ( double const  x )

inline

Definition at line 248 of file misc.h.

References horner().

Referenced by Transform4326ToUTM::calculateX(), TransformUTMTo4326::calculateX(), and TransformUTMTo4326::TransformUTMTo4326().

                                              {
  // Mathematica: CoefficientList[Normal@Series[Sinh[x],{x,0,16}],x] // InputForm
  // clang-format off
  return x * horner(x * x, 1, 1/6., 1/120., 1/5040., 1/362880.,
                    1/39916800., 1/6227020800., 1/1307674368000.);
  // clang-format on
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool shared::file_or_glob_path_exists

(

const std::string &

path

)

Definition at line 174 of file file_path_util.cpp.

References heavyai::glob().

Referenced by DBHandler::detect_column_types(), and DBHandler::import_table().

                                                     {
  return boost::filesystem::exists(path) || !heavyai::glob(path).empty();
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t shared::formatDate	(	char *	buf,
		size_t const	max,
		int64_t const	unixtime
	)

Definition at line 27 of file misc.cpp.

References divUMod(), shared::DivUMod::quot, and shared::DivUMod::rem.

Referenced by convert_temporal_to_iso_format(), convert_to_string_and_encode_date(), and DatumToString().

                                                                       {
  DivUMod const div_day = divUMod(unixtime, 24 * 60 * 60);
  DivUMod const div_era = divUMod(div_day.quot - 11017, 146097);
  unsigned const doe = static_cast<unsigned>(div_era.rem);
  unsigned const yoe = (doe - doe / 1460 + doe / 36524 - (doe == 146096)) / 365;
  unsigned const doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
  unsigned const moy = (5 * doy + 2) / 153;
  static_assert(8 <= sizeof(long long));  // long long needed for snprintf()
  long long const y = 2000 + div_era.quot * 400 + yoe + (9 < moy);
  unsigned const m = moy + (9 < moy ? -9 : 3);
  unsigned const d = doy - (153 * moy + 2) / 5 + 1;
  int const len = snprintf(buf, max, "%04lld-%02u-%02u", y, m, d);
  if (0 <= len && static_cast<size_t>(len) < max) {
    return static_cast<size_t>(len);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t shared::formatDateTime	(	char *	buf,
		size_t const	max,
		int64_t const	timestamp,
		int const	dimension,
		bool	use_iso_format
	)

Definition at line 45 of file misc.cpp.

References divUMod(), shared::DivUMod::quot, and shared::DivUMod::rem.

Referenced by convert_temporal_to_iso_format(), convert_to_string_and_encode_timestamp(), and DatumToString().

                                           {
  constexpr int pow10[10]{
      1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
  DivUMod const div_hip = divUMod(timestamp, pow10[dimension]);
  DivUMod const div_day = divUMod(div_hip.quot, 24 * 60 * 60);
  DivUMod const div_era = divUMod(div_day.quot - 11017, 146097);
  unsigned const doe = static_cast<unsigned>(div_era.rem);
  unsigned const yoe = (doe - doe / 1460 + doe / 36524 - (doe == 146096)) / 365;
  unsigned const doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
  unsigned const moy = (5 * doy + 2) / 153;
  static_assert(8 <= sizeof(long long));  // long long needed for snprintf()
  long long const y = 2000 + div_era.quot * 400 + yoe + (9 < moy);
  unsigned const m = moy + (9 < moy ? -9 : 3);
  unsigned const d = doy - (153 * moy + 2) / 5 + 1;
  unsigned const minutes = static_cast<unsigned>(div_day.rem) / 60;
  unsigned const ss = div_day.rem % 60;
  unsigned const hh = minutes / 60;
  unsigned const mm = minutes % 60;
  const char* date_time_format;
  if (use_iso_format) {
    if (dimension) {
      date_time_format = "%04lld-%02u-%02uT%02u:%02u:%02u";
    } else {
      date_time_format = "%04lld-%02u-%02uT%02u:%02u:%02uZ";
    }
  } else {
    date_time_format = "%04lld-%02u-%02u %02u:%02u:%02u";
  }
  int const len = snprintf(buf, max, date_time_format, y, m, d, hh, mm, ss);
  if (0 <= len && static_cast<size_t>(len) < max) {
    if (dimension) {
      auto precision_format = use_iso_format ? ".%0*dZ" : ".%0*d";
      int const len_frac = snprintf(buf + len,
                                    max - len,
                                    precision_format,
                                    dimension,
                                    static_cast<int>(div_hip.rem));
      if (0 <= len_frac && static_cast<size_t>(len + len_frac) < max) {
        return static_cast<size_t>(len + len_frac);
      }
    } else {
      return static_cast<size_t>(len);
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t shared::formatHMS	(	char *	buf,
		size_t const	max,
		int64_t const	unixtime
	)

Definition at line 96 of file misc.cpp.

References unsignedMod().

Referenced by convert_temporal_to_iso_format(), convert_to_string_and_encode_time(), and DatumToString().

                                                                      {
  unsigned const seconds = static_cast<unsigned>(unsignedMod(unixtime, 24 * 60 * 60));
  unsigned const minutes = seconds / 60;
  unsigned const ss = seconds % 60;
  unsigned const hh = minutes / 60;
  unsigned const mm = minutes % 60;
  int const len = snprintf(buf, max, "%02u:%02u:%02u", hh, mm, ss);
  if (0 <= len && static_cast<size_t>(len) < max) {
    return static_cast<size_t>(len);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename K , typename V , typename comp >

V& shared::get_from_map	(	std::map< K, V, comp > &	map,
		const K &	key
	)

Definition at line 61 of file misc.h.

References CHECK.

Referenced by foreign_storage::append_data_block_to_chunk(), anonymous_namespace{ForeignDataImporter.cpp}::create_fragment_buffers(), Buffer_Namespace::TieredCpuBufferMgr::getAllocatorForSlab(), foreign_storage::ParquetDataWrapper::initializeChunkBuffers(), anonymous_namespace{ForeignDataImporter.cpp}::load_foreign_data_buffers(), foreign_storage::ParquetDataWrapper::loadBuffersUsingLazyParquetChunkLoader(), foreign_storage::LazyParquetChunkLoader::loadRowGroups(), foreign_storage::ParquetDataWrapper::metadataScanRowGroupIntervals(), foreign_storage::partition_data_blocks(), foreign_storage::anonymous_namespace{LazyParquetChunkLoader.cpp}::populate_encoder_map_for_import(), foreign_storage::anonymous_namespace{LazyParquetChunkLoader.cpp}::populate_encoder_map_for_metadata_scan(), foreign_storage::ParquetDataWrapper::removeMetadataForLastFile(), foreign_storage::AbstractTextFileDataWrapper::updateMetadata(), foreign_storage::ParquetDataWrapper::updateMetadataForRolledOffFiles(), and foreign_storage::AbstractTextFileDataWrapper::updateRolledOffChunks().

                                                       {
  auto find_it = map.find(key);
  CHECK(find_it != map.end());
  return find_it->second;
}

Here is the caller graph for this function:

template<typename K , typename V , typename comp >

const V& shared::get_from_map	(	const std::map< K, V, comp > &	map,
		const K &	key
	)

Definition at line 68 of file misc.h.

References CHECK.

                                                                   {
  auto find_it = map.find(key);
  CHECK(find_it != map.end());
  return find_it->second;
}

unsigned shared::getExpOfTwo

(

unsigned

n

)

Definition at line 23 of file MathUtils.cpp.

Referenced by CodeGenerator::markDeadRuntimeFuncs().

                                 {
  unsigned i = 0;

  while ((n = n >> 1)) {
    ++i;
  }

  return i;
}

Here is the caller graph for this function:

constexpr auto shared::heavyai_htonl ( std::uint32_t  h )

inline

Definition at line 428 of file misc.h.

References byteswap().

                                                   {
  return (shared::endian::native == shared::endian::big) ? h : shared::byteswap(h);
}

Here is the call graph for this function:

constexpr auto shared::heavyai_htonll ( std::uint64_t  h )

inline

Definition at line 432 of file misc.h.

References byteswap().

                                                    {
  return (shared::endian::native == shared::endian::big) ? h : shared::byteswap(h);
}

Here is the call graph for this function:

constexpr auto shared::heavyai_htons ( std::uint16_t  h )

inline

Definition at line 424 of file misc.h.

References byteswap().

                                                   {
  return (shared::endian::native == shared::endian::big) ? h : shared::byteswap(h);
}

Here is the call graph for this function:

constexpr auto shared::heavyai_ntohl ( std::uint32_t  n )

inline

Definition at line 440 of file misc.h.

References byteswap().

                                                   {
  return (shared::endian::native == shared::endian::big) ? n : shared::byteswap(n);
}

Here is the call graph for this function:

constexpr auto shared::heavyai_ntohll ( std::uint64_t  n )

inline

Definition at line 444 of file misc.h.

References byteswap().

                                                    {
  return (shared::endian::native == shared::endian::big) ? n : shared::byteswap(n);
}

Here is the call graph for this function:

constexpr auto shared::heavyai_ntohs ( std::uint16_t  n )

inline

Definition at line 436 of file misc.h.

References byteswap().

                                                   {
  return (shared::endian::native == shared::endian::big) ? n : shared::byteswap(n);
}

Here is the call graph for this function:

template<typename... COEFFICIENTS>

DEVICE constexpr double shared::horner	(	double const	x,
		double const	c0,
		COEFFICIENTS...	c
	)

Definition at line 205 of file misc.h.

Referenced by fastAtanh(), fastCos(), fastCosh(), fastSin(), and fastSinh().

                                                                                   {
  if constexpr (sizeof...(COEFFICIENTS) == 0) {  // NOLINT
    return c0;
  } else {
    return horner(x, c...) * x + c0;
  }
  return {};  // quiet nvcc warning https://stackoverflow.com/a/64561686/2700898
}

Here is the caller graph for this function:

template<size_t N>

constexpr std::array<double, N> shared::inversePowersOf

(

double const

a

)

Definition at line 270 of file misc.h.

References anonymous_namespace{misc.h}::inversePowersOfImpl().

                                                              {
  return inversePowersOfImpl(a, std::make_index_sequence<N>{});
}

Here is the call graph for this function:

template<int... values, typename T >

bool shared::is_any ( T &&  value )

inline

Definition at line 258 of file misc.h.

                              {
  return (... || (values == value));
}

bool shared::is_compressed_file_extension

(

const std::string &

location

)

Definition at line 49 of file file_type.cpp.

References contains().

Referenced by foreign_storage::LocalMultiFileReader::insertFile(), and foreign_storage::LocalMultiFileReader::LocalMultiFileReader().

                                                             {
  static const std::vector<std::string> compressed_exts = {
      ".7z", ".bz", ".bz2", ".gz", ".rar", ".tar", ".zip", ".tgz"};
  return shared::contains(compressed_exts, boost::filesystem::extension(location));
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool shared::is_compressed_mime_type

(

const std::string &

mime_type

)

Definition at line 34 of file file_type.cpp.

References contains().

                                                         {
  // strips possible vender (vnd.), personal (prs.) & unregistered (x.) prefixes from the
  // mime-type
  static const std::regex mime_prefix("\\/(vnd|prs|x)(\\.|-)");
  const auto mime_type_no_prefix = std::regex_replace(mime_type, mime_prefix, "/");
  static const std::vector<std::string> compressed_types = {"application/7z-compressed",
                                                            "application/bzip",
                                                            "application/bzip2",
                                                            "application/gzip",
                                                            "application/rar",
                                                            "application/tar",
                                                            "application/zip"};
  return shared::contains(compressed_types, mime_type_no_prefix);
}

Here is the call graph for this function:

bool shared::isPowOfTwo

(

unsigned

n

)

Definition at line 19 of file MathUtils.cpp.

                            {
  return (n & (n - 1)) == 0;
}

std::vector< std::string > shared::local_glob_filter_sort_files	(	const std::string &	file_path,
		const FilePathOptions &	options,
		const bool	recurse
	)

Definition at line 109 of file file_path_util.cpp.

References shared::FilePathOptions::filter_regex, shared::anonymous_namespace{file_path_util.cpp}::glob_local_recursive_files(), PATHNAME_ORDER_TYPE, shared::anonymous_namespace{file_path_util.cpp}::regex_file_filter(), and shared::FilePathOptions::sort_by.

Referenced by import_export::DataStreamSink::archivePlumber(), DBHandler::detect_column_types(), ddl_utils::get_expanded_file_paths(), foreign_storage::ParquetDataWrapper::getAllFilePaths(), foreign_storage::LocalMultiFileReader::getAllFilePaths(), DBHandler::importGeoTableGlobFilterSort(), and foreign_storage::LocalMultiFileReader::LocalMultiFileReader().

                                                                          {
  auto result_files = glob_local_recursive_files(file_path, recurse);
  if (options.filter_regex.has_value()) {
    result_files = regex_file_filter(options.filter_regex.value(), result_files);
  }
  // initial lexicographical order ensures a determinisitc ordering for files not matching
  // sort_regex
  FilePathOptions temp_options;
  temp_options.sort_by = PATHNAME_ORDER_TYPE;
  auto initial_file_order = FileOrderLocal(temp_options);
  auto lexi_comp = initial_file_order.getFileComparator();
  std::stable_sort(result_files.begin(), result_files.end(), lexi_comp);

  auto file_order = FileOrderLocal(options);
  auto comp = file_order.getFileComparator();
  std::stable_sort(result_files.begin(), result_files.end(), comp);
  return result_files;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename OSTREAM , typename CONTAINER >

OSTREAM& shared::operator<<	(	OSTREAM &	os,
		PrintContainer< CONTAINER >	pc
	)

Definition at line 125 of file misc.h.

References printContainer().

                                                               {
  if (pc.container.empty()) {
    return os << "()";
  } else {
    if constexpr (is_std_container<typename CONTAINER::value_type>::value) {  // NOLINT
      os << '(';
      for (auto& container : pc.container) {
        os << printContainer(container);
      }
    } else {
      for (auto itr = pc.container.begin(); itr != pc.container.end(); ++itr) {
        if constexpr (std::is_pointer_v<typename CONTAINER::value_type>) {  // NOLINT
          os << (itr == pc.container.begin() ? '(' : ' ') << (void const*)*itr;
        } else {
          os << (itr == pc.container.begin() ? '(' : ' ') << *itr;
        }
      }
    }
    return os << ')';
  }
}

Here is the call graph for this function:

double shared::power10 ( unsigned const  x )

inline

Definition at line 275 of file misc.h.

References anonymous_namespace{Utm.h}::N.

Referenced by Analyzer::anonymous_namespace{Analyzer.cpp}::floatFromDecimal(), and anonymous_namespace{CalciteAdapter.cpp}::pg_shim_impl().

                                        {
  constexpr unsigned N = 20;
  constexpr auto pow10 = powersOf<double, N>(10.0);
  return x < N ? pow10[x] : (pow10[N - 1] * 10) * power10(x - N);
}

Here is the caller graph for this function:

double shared::power10inv ( unsigned const  x )

inline

Definition at line 282 of file misc.h.

References anonymous_namespace{Utm.h}::N.

Referenced by CodeGenerator::codegenCastToFp(), and convert_to_string_and_encode_decimal().

                                           {
  constexpr unsigned N = 20;
  constexpr auto pow10inv = inversePowersOf<N>(10.0);
  return x < N ? pow10inv[x] : (pow10inv[N - 1] / 10) * power10inv(x - N);
}

Here is the caller graph for this function:

template<typename T , size_t N>

constexpr std::array<T, N> shared::powersOf

(

T const

a

)

Definition at line 264 of file misc.h.

References anonymous_namespace{Utm.h}::a.

                                             {
  return powersOfImpl<T>(a, std::make_index_sequence<N>{});
}

template<typename CONTAINER >

PrintContainer<CONTAINER> shared::printContainer

(

CONTAINER &

container

)

Definition at line 107 of file misc.h.

Referenced by QueryFragmentDescriptor::buildFragmentPerKernelMapForUnion(), RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createUnionWorkUnit(), Executor::executePlanWithGroupBy(), Executor::fetchUnionChunks(), import_export::import_thread_delimited(), operator<<(), operator<<(), ddl_utils::set_whitelisted_paths(), anonymous_namespace{RelAlgExecutor.cpp}::target_exprs_for_union(), and TableOptimizer::vacuumFragmentsAboveMinSelectivity().

                                                               {
  return {container};
}

Here is the caller graph for this function:

template<typename TO , typename FROM >

TO shared::reinterpret_bits ( FROM const  from )

inline

Definition at line 291 of file misc.h.

                                            {
  TO to{0};
  memcpy(&to, &from, sizeof(TO) < sizeof(FROM) ? sizeof(TO) : sizeof(FROM));
  return to;
}

template<typename... STR>

constexpr std::array<std::string_view, sizeof...(STR)> shared::string_view_array

(

STR &&...

str

)

Definition at line 315 of file misc.h.

                                                                                   {
  return {std::forward<STR>(str)...};
}

void shared::throw_file_not_found ( const std::string &  file_path )

inline

Definition at line 78 of file file_path_util.h.

Referenced by shared::anonymous_namespace{file_path_util.cpp}::glob_local_recursive_files().

                                                             {
  throw FileNotFoundException{"File or directory \"" + file_path + "\" does not exist."};
}

Here is the caller graph for this function:

void shared::throw_no_filter_match ( const std::string &  pattern )

inline

Definition at line 88 of file file_path_util.h.

Referenced by shared::anonymous_namespace{file_path_util.cpp}::regex_file_filter(), and foreign_storage::anonymous_namespace{S3FilePathUtil.cpp}::s3_objects_regex_file_filter().

                                                            {
  throw NoRegexFilterMatchException{"No files matched the regex file path \"" + pattern +
                                    "\"."};
}

Here is the caller graph for this function:

template<typename OUTPUT , typename INPUT , typename FUNC >

OUTPUT shared::transform	(	INPUT const &	input,
		FUNC const &	func
	)

Definition at line 320 of file misc.h.

Referenced by anonymous_namespace{ArrowResultSetConverter.cpp}::appendToColumnBuilder(), anonymous_namespace{ArrowResultSetConverter.cpp}::appendToListColumnBuilder(), anonymous_namespace{ArrowResultSetConverter.cpp}::appendToListColumnBuilder< arrow::StringDictionaryBuilder, int64_t >(), StringDictionaryProxy::buildIntersectionTranslationMapToOtherProxyUnlocked(), ResultSetReductionJIT::cacheKey(), HashJoin::collectFragmentIds(), UdfCompiler::compileFromCommandLine(), decode_base64_uri(), import_export::Detector::detect_sqltype(), TableArchiver::dumpTable(), ThriftSerializers::from_thrift(), UdfCompiler::generateAST(), Parser::LikeExpr::get(), anonymous_namespace{RelAlgExecutor.cpp}::get_raw_pointers(), anonymous_namespace{ResultSetReductionInterpreter.cpp}::get_value_types(), ShowTableDetailsCommand::getFilteredTableNames(), anonymous_namespace{ResultSetReductionCodegen.cpp}::llvm_args(), parse_stats_requests_json(), ArrowForeignStorageBase::read(), TableArchiver::restoreTable(), Catalog_Namespace::SysCatalog::syncUserWithRemoteProvider(), to_lower(), ThriftSerializers::to_thrift(), to_upper(), com.mapd.parser.extension.ddl.SqlLeadLag::transformType(), anonymous_namespace{ResultSetReductionCodegen.cpp}::translate_body(), and anonymous_namespace{ExternalExecutor.cpp}::vt_create().

                                                       {
  OUTPUT output;
  output.reserve(input.size());
  for (auto const& x : input) {
    output.push_back(func(x));
  }
  return output;
}

Here is the caller graph for this function:

uint64_t shared::unsignedMod ( int64_t  num, int64_t  den  )

inline

Definition at line 186 of file misc.h.

Referenced by formatHMS().

                                                      {
  int64_t mod = num % den;
  if (mod < 0) {
    mod += den;
  }
  return mod;
}

Here is the caller graph for this function:

void shared::validate_sort_options

(

const FilePathOptions &

options

)

Definition at line 32 of file file_path_util.cpp.

References contains(), FILE_SORT_ORDER_BY_KEY, FILE_SORT_REGEX_KEY, join(), non_regex_sort_order_types, PATHNAME_ORDER_TYPE, regex_sort_order_types, shared::FilePathOptions::sort_by, shared::FilePathOptions::sort_regex, supported_file_sort_order_types, and to_upper().

Referenced by import_export::DataStreamSink::archivePlumber(), import_export::ForeignDataImporter::importGeneralS3(), DBHandler::importGeoTableGlobFilterSort(), and foreign_storage::AbstractFileStorageDataWrapper::validateTableOptions().

                                                           {
  const auto sort_by_str = to_upper(options.sort_by.value_or(PATHNAME_ORDER_TYPE));

  if (!shared::contains(supported_file_sort_order_types, sort_by_str)) {
    throw std::runtime_error{FILE_SORT_ORDER_BY_KEY +
                             " must be one of the following options: " +
                             join(supported_file_sort_order_types, ", ") + "."};
  }

  if (shared::contains(non_regex_sort_order_types, sort_by_str) &&
      options.sort_regex.has_value()) {
    throw std::runtime_error{"Option \"" + FILE_SORT_REGEX_KEY +
                             "\" must not be set for selected option \"" +
                             FILE_SORT_ORDER_BY_KEY + "='" + sort_by_str + "'\"."};
  }

  if (shared::contains(regex_sort_order_types, sort_by_str) &&
      !options.sort_regex.has_value()) {
    throw std::runtime_error{"Option \"" + FILE_SORT_REGEX_KEY +
                             "\" must be set for selected option \"" +
                             FILE_SORT_ORDER_BY_KEY + "='" + sort_by_str + "'\"."};
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

const std::function<bool(const std::string&, const std::string&)> shared::common_regex_date_comp_

Initial value:

= [](const std::string& lhs, const std::string& rhs) -> bool {
  int64_t lhs_t;
  int64_t rhs_t;
  try {
    lhs_t = dateTimeParse<kDATE>(lhs, 0);
  } catch (const std::exception& e) {
    lhs_t = 0;
  }
  try {
    rhs_t = dateTimeParse<kDATE>(rhs, 0);
  } catch (const std::exception& e) {
    rhs_t = 0;
  }
  return lhs_t < rhs_t;
}

Definition at line 112 of file file_path_util.h.

const std::function<bool(const std::string&, const std::string&)> shared::common_regex_number_comp_

Initial value:

=
        [](const std::string& lhs, const std::string& rhs) -> bool {
  int64_t lhs_i;
  int64_t rhs_i;
  try {
    lhs_i = stoll(lhs, 0);
  } catch (const std::exception& e) {
    lhs_i = 0;
  }
  try {
    rhs_i = stoll(rhs, 0);
  } catch (const std::exception& e) {
    rhs_i = 0;
  }
  return lhs_i < rhs_i;
}

Definition at line 128 of file file_path_util.h.

const std::string shared::DATE_MODIFIED_ORDER_TYPE = "DATE_MODIFIED"

inline

Definition at line 52 of file file_path_util.h.

const std::string shared::FILE_SORT_ORDER_BY_KEY = "FILE_SORT_ORDER_BY"

inline

Definition at line 48 of file file_path_util.h.

Referenced by validate_sort_options().

const std::string shared::FILE_SORT_REGEX_KEY = "FILE_SORT_REGEX"

inline

Definition at line 49 of file file_path_util.h.

Referenced by validate_sort_options().

const std::string shared::kCatalogDirectoryName = "catalogs"

inline

Definition at line 41 of file SysDefinitions.h.

Referenced by Catalog_Namespace::CommonFileOperations::assembleCatalogName(), anonymous_namespace{SysCatalog.cpp}::copy_catalog_if_read_only(), Catalog_Namespace::SysCatalog::createDatabase(), Catalog_Namespace::Catalog::eraseDbMetadata(), migrations::MigrationMgr::executeRebrandMigration(), lockmgr::TableLockMgrImpl< TableDataLockMgr >::getClusterTableMutex(), Catalog_Namespace::SysCatalog::importDataFromOldMapdDB(), Catalog_Namespace::SysCatalog::init(), main(), CommandLineOptions::parse_command_line(), QueryRunner::QueryRunner::QueryRunner(), Catalog_Namespace::anonymous_namespace{Catalog.cpp}::table_json_filepath(), and CommandLineOptions::validate().

const std::string shared::kDataDirectoryName = "data"

inline

Definition at line 42 of file SysDefinitions.h.

Referenced by Catalog_Namespace::Catalog::buildDictionaryMapUnlocked(), Data_Namespace::DataMgr::convertDB(), Catalog_Namespace::Catalog::delDictionary(), migrations::MigrationMgr::executeRebrandMigration(), lockmgr::TableLockMgrImpl< TableDataLockMgr >::getClusterTableMutex(), QueryRunner::ImportDriver::importGeoTable(), DBHandler::initialize(), main(), CommandLineOptions::parse_command_line(), QueryRunner::QueryRunner::QueryRunner(), Catalog_Namespace::Catalog::reloadTableMetadataUnlocked(), Catalog_Namespace::Catalog::setColumnDictionary(), startHeavyDBServer(), Catalog_Namespace::Catalog::updateDictionaryNames(), and CommandLineOptions::validate().

const std::string shared::kDefaultDbName = "heavyai"

inline

Definition at line 27 of file SysDefinitions.h.

Referenced by Catalog_Namespace::SysCatalog::createRole_unsafe(), Catalog_Namespace::SysCatalog::getMetadataWithDefaultDB(), EmbeddedDatabase::DBEngineImpl::init(), QueryRunner::QueryRunner::init(), Catalog_Namespace::SysCatalog::initDB(), loadGeo(), and QueryRunner::QueryRunner::QueryRunner().

const std::string shared::kDefaultDiskCacheDirName = "disk_cache"

inline

Definition at line 37 of file SysDefinitions.h.

Referenced by File_Namespace::DiskCacheConfig::getDefaultPath(), main(), QueryRunner::QueryRunner::QueryRunner(), and CommandLineOptions::validate().

const std::string shared::kDefaultExportDirName = "export"

inline

Definition at line 35 of file SysDefinitions.h.

Referenced by Parser::ExportQueryStmt::execute(), migrations::MigrationMgr::executeRebrandMigration(), ddl_utils::FilePathWhitelist::initialize(), and main().

const std::string shared::kDefaultImportDirName = "import"

inline

Definition at line 36 of file SysDefinitions.h.

Referenced by migrations::MigrationMgr::executeRebrandMigration(), ddl_utils::FilePathWhitelist::initialize(), DBHandler::initialize(), and import_export::ForeignDataImporter::setDefaultImportPath().

const std::string shared::kDefaultKeyFileName = "heavyai.pem"

inline

Definition at line 38 of file SysDefinitions.h.

Referenced by migrations::MigrationMgr::executeRebrandMigration().

const std::string shared::kDefaultKeyStoreDirName = "key_store"

inline

Definition at line 39 of file SysDefinitions.h.

Referenced by migrations::MigrationMgr::executeRebrandMigration().

const std::string shared::kDefaultLicenseFileName = "heavyai.license"

inline

Definition at line 44 of file SysDefinitions.h.

Referenced by migrations::MigrationMgr::executeRebrandMigration(), and CommandLineOptions::validate().

const std::string shared::kDefaultLogDirName = "log"

inline

Definition at line 40 of file SysDefinitions.h.

Referenced by migrations::MigrationMgr::executeRebrandMigration(), start_calcite_server_as_daemon(), and CommandLineOptions::validate().

const std::string shared::kDefaultRootPasswd = "HyperInteractive"

inline

Definition at line 31 of file SysDefinitions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and Catalog_Namespace::SysCatalog::initDB().

const std::string shared::kInfoSchemaDbName = "information_schema"

inline

Definition at line 33 of file SysDefinitions.h.

Referenced by dbhandler::check_not_info_schema_db(), foreign_storage::anonymous_namespace{InternalCatalogDataWrapper.cpp}::get_all_dashboards(), foreign_storage::anonymous_namespace{InternalCatalogDataWrapper.cpp}::get_all_tables(), Catalog_Namespace::SysCatalog::initializeInformationSchemaDb(), foreign_storage::InternalStorageStatsDataWrapper::initializeObjectsForTable(), dbhandler::is_info_schema_db(), Catalog_Namespace::Catalog::isInfoSchemaDb(), foreign_storage::InternalSystemDataWrapper::populateChunkBuffers(), and foreign_storage::InternalSystemDataWrapper::populateChunkMetadata().

const std::string shared::kInfoSchemaMigrationName = "information_schema_db_created"

inline

Definition at line 34 of file SysDefinitions.h.

Referenced by Catalog_Namespace::SysCatalog::initializeInformationSchemaDb(), and dbhandler::is_info_schema_db().

const std::string shared::kLockfilesDirectoryName = "lockfiles"

inline

Definition at line 43 of file SysDefinitions.h.

Referenced by lockmgr::TableLockMgrImpl< TableDataLockMgr >::getClusterTableMutex(), Catalog_Namespace::SysCatalog::init(), main(), CommandLineOptions::parse_command_line(), and migrations::MigrationMgr::takeMigrationLock().

const int shared::kRootUserId = 0

inline

Definition at line 29 of file SysDefinitions.h.

Referenced by Catalog_Namespace::SysCatalog::createDatabase(), Catalog_Namespace::Catalog::createDefaultServersIfNotExists(), Catalog_Namespace::Catalog::createSystemTableServer(), Catalog_Namespace::Catalog::getSystemTableSchema(), Catalog_Namespace::SysCatalog::initDB(), Catalog_Namespace::SysCatalog::initializeInformationSchemaDb(), Catalog_Namespace::SysCatalog::migrateDBAccessPrivileges(), Catalog_Namespace::SysCatalog::migratePrivileges(), and Catalog_Namespace::Catalog::updateTableDescriptorSchema().

const std::string shared::kRootUserIdStr = "0"

inline

Definition at line 30 of file SysDefinitions.h.

Referenced by Catalog_Namespace::SysCatalog::initDB().

const std::string shared::kRootUsername = "admin"

inline

Definition at line 28 of file SysDefinitions.h.

Referenced by Catalog_Namespace::SysCatalog::addAdminUserRole(), Catalog_Namespace::SysCatalog::buildUserRoleMapUnlocked(), Parser::GrantRoleStmt::execute(), Parser::RevokeRoleStmt::execute(), EmbeddedDatabase::DBEngineImpl::init(), QueryRunner::QueryRunner::init(), Catalog_Namespace::SysCatalog::initDB(), and loadGeo().

const std::string shared::kSystemCatalogName = "system_catalog"

inline

Definition at line 26 of file SysDefinitions.h.

Referenced by Catalog_Namespace::SysCatalog::buildMapsUnlocked(), Catalog_Namespace::SysCatalog::createDatabase(), migrations::MigrationMgr::executeRebrandMigration(), Catalog_Namespace::SysCatalog::importDataFromOldMapdDB(), Catalog_Namespace::SysCatalog::init(), Catalog_Namespace::SysCatalog::name(), Catalog_Namespace::SysCatalog::renameDatabase(), and CommandLineOptions::validate().

const int32_t shared::kTempUserIdRange = 1000000000

inline

Definition at line 32 of file SysDefinitions.h.

const std::array<std::string, 2> shared::non_regex_sort_order_types

inline

Initial value:

{
    PATHNAME_ORDER_TYPE,
    DATE_MODIFIED_ORDER_TYPE}

Definition at line 64 of file file_path_util.h.

Referenced by validate_sort_options().

const std::string shared::PATHNAME_ORDER_TYPE = "PATHNAME"

inline

Definition at line 51 of file file_path_util.h.

Referenced by shared::FileOrderBase< LocalFileComparator >::getSortBy(), local_glob_filter_sort_files(), foreign_storage::s3_objects_filter_sort_files(), and validate_sort_options().

const std::string shared::REGEX_DATE_ORDER_TYPE = "REGEX_DATE"

inline

Definition at line 54 of file file_path_util.h.

const std::string shared::REGEX_NUMBER_ORDER_TYPE = "REGEX_NUMBER"

inline

Definition at line 55 of file file_path_util.h.

const std::string shared::REGEX_ORDER_TYPE = "REGEX"

inline

Definition at line 53 of file file_path_util.h.

const std::array<std::string, 3> shared::regex_sort_order_types

inline

Initial value:

{REGEX_ORDER_TYPE,
                                                               REGEX_DATE_ORDER_TYPE,
                                                               REGEX_NUMBER_ORDER_TYPE}

Definition at line 68 of file file_path_util.h.

Referenced by validate_sort_options().

const std::array<std::string, 5> shared::supported_file_sort_order_types

inline

Initial value:

{
    PATHNAME_ORDER_TYPE,
    DATE_MODIFIED_ORDER_TYPE,
    REGEX_ORDER_TYPE,
    REGEX_DATE_ORDER_TYPE,
    REGEX_NUMBER_ORDER_TYPE}

Definition at line 57 of file file_path_util.h.

Referenced by validate_sort_options().