Namespaces
	allocator

Classes
class	MutexInterface

class	SharedMutexInterface

class	DistributedSharedMutex

struct	StringEnum

struct	IsAny

struct	DeviceIdentifier

class	JSON

class	InSituFlagsOwnerInterface

class	UUID

class	RequestInfo

Typedefs
using	DeviceGroup = std::vector< DeviceIdentifier >

using	shared_mutex = std::shared_timed_mutex

template<typename T >
using	lock_guard = std::lock_guard< T >

template<typename T >
using	unique_lock = std::unique_lock< T >

template<typename T >
using	shared_lock = std::shared_lock< T >

Enumerations
enum	InSituFlags { InSituFlags::kInSitu = 1u << 0, InSituFlags::kNonInSitu = 1u << 1, InSituFlags::kForcedNonInSitu = (kInSitu \| kNonInSitu) }

Functions
size_t	file_size (const int fd)

void *	checked_mmap (const int fd, const size_t sz)

void	checked_munmap (void *addr, size_t length)

int	msync (void *addr, size_t length, bool async)

int	fsync (int fd)

int	open (const char *path, int flags, int mode)

void	close (const int fd)

::FILE *	fopen (const char filename, const char mode)

::FILE *	popen (const char command, const char type)

int32_t	pclose (::FILE *fh)

int	get_page_size ()

int32_t	ftruncate (const int32_t fd, int64_t length)

int	safe_open (const char *path, int flags, mode_t mode) noexcept

int	safe_close (int fd) noexcept

int	safe_fcntl (int fd, int cmd, struct flock *fl) noexcept

ssize_t	safe_read (const int fd, void *buffer, const size_t buffer_size) noexcept

ssize_t	safe_write (const int fd, const void *buffer, const size_t buffer_size) noexcept

int32_t	safe_ftruncate (const int32_t fd, int64_t length) noexcept

std::vector< std::string >	glob (const std::string &pattern)

std::string	get_hostname ()

std::string	get_root_abs_path ()

	HEAVYAI_DEFINE_ENUM_CLASS_WITH_DESCRIPTIONS (ErrorCode,(NO_ERROR,"No Error"),(DIV_BY_ZERO,"Division by zero"),(OUT_OF_GPU_MEM,"Query couldn't keep the entire working set of columns in GPU memory"),(OUT_OF_SLOTS,"Out of Slots"),(UNSUPPORTED_SELF_JOIN,"Self joins not supported yet"),(OUT_OF_RENDER_MEM,"Insufficient GPU memory for query results in render output buffer sized by ""render-mem-bytes"),(OUT_OF_CPU_MEM,"Not enough host memory to execute the query"),(OVERFLOW_OR_UNDERFLOW,"Overflow or underflow"),(OUT_OF_TIME,"Query execution has exceeded the time limit"),(INTERRUPTED,"Query execution has been interrupted"),(COLUMNAR_CONVERSION_NOT_SUPPORTED,"Columnar conversion not supported for variable length types"),(TOO_MANY_LITERALS,"Too many literals in the query"),(STRING_CONST_IN_RESULTSET,"NONE ENCODED String types are not supported as input result set."),(STREAMING_TOP_N_NOT_SUPPORTED_IN_RENDER_QUERY,"Streaming-Top-N not supported in Render Query"),(SINGLE_VALUE_FOUND_MULTIPLE_VALUES,"Multiple distinct values encountered"),(GEOS,"Geo-related error"),(WIDTH_BUCKET_INVALID_ARGUMENT,"Arguments of WIDTH_BUCKET function does not satisfy the condition"),(BBOX_OVERLAPS_LIMIT_EXCEEDED,"Maximum supported number of bounding box overlaps exceeded")) HEAVYAI_DEFINE_ENUM_CLASS(QueryDescriptionType

template<typename Enum , size_t... I>
constexpr auto	enum_to_array (std::index_sequence< I...>)

template<typename T , size_t N>
constexpr void	insertion_sort (std::array< T, N > &arr)

template<typename Enum >
constexpr std::array < StringEnum< Enum >, size_t(Enum::N_)>	sort_by_name ()

template<typename Enum >
std::optional< Enum >	to_enum (std::string_view const name)

bool	operator== (const JSON &json1, const JSON &json2)

bool	operator!= (const JSON &json1, const JSON &json2)

template<typename T >
bool	operator== (const JSON &json, const T &value)

template<typename T >
bool	operator== (const T &value, const JSON &json)

template<typename T >
bool	operator!= (const JSON &json, const T &value)

template<typename T >
bool	operator!= (const T &value, const JSON &json)

bool	operator== (const UUID &lhs, const UUID &rhs) noexcept

bool	operator!= (const UUID &lhs, const UUID &rhs) noexcept

bool	operator< (const UUID &lhs, const UUID &rhs) noexcept

std::string	to_string (const UUID &uuid)

Variables
	GroupByPerfectHash

	GroupByBaselineHash

	Projection

	TableFunction

	NonGroupedAggregate

constexpr UUID	empty_uuid {}

Typedef Documentation

using heavyai::DeviceGroup = typedef std::vector<DeviceIdentifier>

Definition at line 31 of file DeviceGroup.h.

template<typename T >

using heavyai::lock_guard = typedef std::lock_guard<T>

Definition at line 37 of file heavyai_shared_mutex.h.

template<typename T >

using heavyai::shared_lock = typedef std::shared_lock<T>

Definition at line 41 of file heavyai_shared_mutex.h.

using heavyai::shared_mutex = typedef std::shared_timed_mutex

Definition at line 31 of file heavyai_shared_mutex.h.

template<typename T >

using heavyai::unique_lock = typedef std::unique_lock<T>

Definition at line 39 of file heavyai_shared_mutex.h.

Enumeration Type Documentation

enum heavyai::InSituFlags

strong

Enumerator
kInSitu
kNonInSitu
kForcedNonInSitu

Definition at line 23 of file InSituFlags.h.

                        {
   kInSitu = 1u << 0,
   kNonInSitu = 1u << 1,
   kForcedNonInSitu = (kInSitu | kNonInSitu)
 };

Function Documentation

void * heavyai::checked_mmap	(	const int	fd,
		const size_t	sz
	)

Definition at line 40 of file heavyai_fs.cpp.

References CHECK.

Referenced by StringDictionary::checkAndConditionallyIncreaseOffsetCapacity(), StringDictionary::checkAndConditionallyIncreasePayloadCapacity(), and StringDictionary::StringDictionary().

                                                   {
   auto ptr = mmap(nullptr, sz, PROT_WRITE | PROT_READ, MAP_SHARED, fd, 0);
   CHECK(ptr != reinterpret_cast<void*>(-1));
 #ifdef __linux__
 #ifdef MADV_HUGEPAGE
   madvise(ptr, sz, MADV_RANDOM | MADV_WILLNEED | MADV_HUGEPAGE);
 #else
   madvise(ptr, sz, MADV_RANDOM | MADV_WILLNEED);
 #endif
 #endif
   return ptr;
 }

Here is the caller graph for this function:

void heavyai::checked_munmap	(	void *	addr,
		size_t	length
	)

Definition at line 53 of file heavyai_fs.cpp.

References CHECK_EQ.

Referenced by StringDictionary::checkAndConditionallyIncreaseOffsetCapacity(), StringDictionary::checkAndConditionallyIncreasePayloadCapacity(), and StringDictionary::~StringDictionary().

                                                {
   CHECK_EQ(0, munmap(addr, length));
 }

Here is the caller graph for this function:

void heavyai::close ( const int fd )

Definition at line 70 of file heavyai_fs.cpp.

Referenced by import_export::DataStreamSink::import_compressed(), safe_close(), and StringDictionary::~StringDictionary().

                          {
   ::close(fd);
 }

Here is the caller graph for this function:

template<typename Enum , size_t... I>

constexpr auto heavyai::enum_to_array ( std::index_sequence< I...> )

Definition at line 93 of file define_enum_class.h.

References to_string().

                                                       {
   return std::array<StringEnum<Enum>, sizeof...(I)>{
       StringEnum<Enum>{to_string(static_cast<Enum>(I)), static_cast<Enum>(I)}...};
 }

Here is the call graph for this function:

size_t heavyai::file_size ( const int fd )

Definition at line 33 of file heavyai_fs.cpp.

References CHECK_EQ.

Referenced by get_filesize(), File_Namespace::FileMgr::getMetadataForFile(), File_Namespace::TableFileMgr::getReservedSpace(), File_Namespace::FileMgr::openAndReadEpochFile(), File_Namespace::FileMgr::openAndReadLegacyEpochFile(), File_Namespace::FileMgr::readPageMappingsFromStatusFile(), File_Namespace::FileMgr::readVersionFromDisk(), anonymous_namespace{CachingFileMgr.cpp}::size_of_dir(), StringDictionary::StringDictionary(), File_Namespace::TableFileMgr::TableFileMgr(), and anonymous_namespace{TableArchiver.cpp}::update_or_drop_column_ids_in_page_headers().

                                {
   struct stat buf;
   int err = fstat(fd, &buf);
   CHECK_EQ(0, err);
   return buf.st_size;
 }

Here is the caller graph for this function:

FILE * heavyai::fopen	(	const char *	filename,
		const char *	mode
	)

Definition at line 74 of file heavyai_fs.cpp.

Referenced by foreign_storage::SingleTextFileReader::checkForMoreRows(), File_Namespace::create(), TableArchiver::dumpTable(), import_export::Detector::importDelimited(), import_export::Importer::importDelimited(), PosixFileArchive::init_for_read(), File_Namespace::open(), foreign_storage::SingleTextFileReader::SingleTextFileReader(), and anonymous_namespace{TableArchiver.cpp}::update_or_drop_column_ids_in_page_headers().

                                                     {
   return ::fopen(filename, mode);
 }

Here is the caller graph for this function:

int heavyai::fsync ( int fd )

Definition at line 62 of file heavyai_fs.cpp.

Referenced by StringDictionary::checkpoint(), File_Namespace::FileInfo::syncToDisk(), File_Namespace::TableFileMgr::writeAndSyncEpochToDisk(), File_Namespace::FileMgr::writeAndSyncEpochToDisk(), and File_Namespace::FileMgr::writeAndSyncVersionToDisk().

                   {
   return ::fsync(fd);
 }

Here is the caller graph for this function:

int32_t heavyai::ftruncate	(	const int32_t	fd,
		int64_t	length
	)

Definition at line 86 of file heavyai_fs.cpp.

Referenced by safe_ftruncate(), and CommandLineOptions::validate().

                                                     {
   return ::ftruncate(fd, length);
 }

Here is the caller graph for this function:

std::string heavyai::get_hostname ( )

Definition at line 23 of file heavyai_hostname.cpp.

Referenced by DBHandler::get_server_status(), and DBHandler::get_status().

                          {
   char hostname[_POSIX_HOST_NAME_MAX];
   gethostname(hostname, _POSIX_HOST_NAME_MAX);
   return {hostname};
 }

Here is the caller graph for this function:

int heavyai::get_page_size ( )

Definition at line 29 of file heavyai_fs.cpp.

                     {
   return getpagesize();
 }

std::string heavyai::get_root_abs_path ( )

Definition at line 40 of file heavyai_path.cpp.

References CHECK, CHECK_EQ, CHECK_GT, and CHECK_LT.

Referenced by get_runtime_test_lib_path(), get_runtime_test_lib_tfs_path(), get_torch_table_functions_path(), Geospatial::GDAL::init(), Executor::initialize_extension_module_sources(), loadGeo(), and start_calcite_server_as_daemon().

                               {
 #ifdef ENABLE_EMBEDDED_DATABASE
   void* const handle = dlopen(DBEngine_LIBNAME, RTLD_LAZY | RTLD_NOLOAD);
   if (handle) {
     /* Non-zero handle means that libDBEngine.so has been loaded and
        the omnisci root path will be determined with respect to the
        location of the shared library rather than the appliction
        `/proc/self/exe` path. */
     const struct link_map* link_map = 0;
     const int ret = dlinfo(handle, RTLD_DI_LINKMAP, &link_map);
     CHECK_EQ(ret, 0);
     CHECK(link_map);
     /* Despite the dlinfo man page claim that l_name is absolute path,
        it is so only when the location path to the library is absolute,
        say, as specified in LD_LIBRARY_PATH. */
     boost::filesystem::path abs_exe_dir(boost::filesystem::absolute(
         boost::filesystem::canonical(std::string(link_map->l_name))));
     abs_exe_dir.remove_filename();
 #ifdef XCODE
     const auto mapd_root = abs_exe_dir.parent_path().parent_path();
 #else
     const auto mapd_root = abs_exe_dir.parent_path();
 #endif
     return mapd_root.string();
   }
 #endif
 #ifdef __APPLE__
   char abs_exe_path[PROC_PIDPATHINFO_MAXSIZE] = {0};
   auto path_len = proc_pidpath(getpid(), abs_exe_path, sizeof(abs_exe_path));
 #else
   char abs_exe_path[PATH_MAX] = {0};
   auto path_len = readlink("/proc/self/exe", abs_exe_path, sizeof(abs_exe_path));
 #endif
   CHECK_GT(path_len, 0);
   CHECK_LT(static_cast<size_t>(path_len), sizeof(abs_exe_path));
   boost::filesystem::path abs_exe_dir(std::string(abs_exe_path, path_len));
   abs_exe_dir.remove_filename();
 #ifdef XCODE
   const auto mapd_root = abs_exe_dir.parent_path().parent_path();
 #else
   const auto mapd_root = abs_exe_dir.parent_path();
 #endif
   return mapd_root.string();
 }

Here is the caller graph for this function:

std::vector< std::string > heavyai::glob ( const std::string & pattern )

Definition at line 24 of file heavyai_glob.cpp.

Referenced by shared::file_or_glob_path_exists(), anonymous_namespace{heavyai_glob.cpp}::glob(), and shared::anonymous_namespace{file_path_util.cpp}::glob_local_recursive_files().

                                                     {
   std::vector<std::string> results;
   glob_t glob_result;
   ::glob(pattern.c_str(), GLOB_BRACE | GLOB_TILDE, nullptr, &glob_result);
   for (size_t i = 0; i < glob_result.gl_pathc; i++) {
     results.emplace_back(glob_result.gl_pathv[i]);
   }
   globfree(&glob_result);
   return results;
 }

Here is the caller graph for this function:

heavyai::HEAVYAI_DEFINE_ENUM_CLASS_WITH_DESCRIPTIONS	(	ErrorCode	,
		(NO_ERROR,"No Error")	,
		(DIV_BY_ZERO,"Division by zero")	,
		(OUT_OF_GPU_MEM,"Query couldn't keep the entire working set of columns in GPU memory")	,
		(OUT_OF_SLOTS,"Out of Slots")	,
		(UNSUPPORTED_SELF_JOIN,"Self joins not supported yet")	,
		(OUT_OF_RENDER_MEM,"Insufficient GPU memory for query results in render output buffer sized by ""render-mem-bytes")	,
		(OUT_OF_CPU_MEM,"Not enough host memory to execute the query")	,
		(OVERFLOW_OR_UNDERFLOW,"Overflow or underflow")	,
		(OUT_OF_TIME,"Query execution has exceeded the time limit")	,
		(INTERRUPTED,"Query execution has been interrupted")	,
		(COLUMNAR_CONVERSION_NOT_SUPPORTED,"Columnar conversion not supported for variable length types")	,
		(TOO_MANY_LITERALS,"Too many literals in the query")	,
		(STRING_CONST_IN_RESULTSET,"NONE ENCODED String types are not supported as input result set.")	,
		(STREAMING_TOP_N_NOT_SUPPORTED_IN_RENDER_QUERY,"Streaming-Top-N not supported in Render Query")	,
		(SINGLE_VALUE_FOUND_MULTIPLE_VALUES,"Multiple distinct values encountered")	,
		(GEOS,"Geo-related error")	,
		(WIDTH_BUCKET_INVALID_ARGUMENT,"Arguments of WIDTH_BUCKET function does not satisfy the condition")	,
		(BBOX_OVERLAPS_LIMIT_EXCEEDED,"Maximum supported number of bounding box overlaps exceeded")
	)

template<typename T , size_t N>

constexpr void heavyai::insertion_sort ( std::array< T, N > & arr )

Definition at line 99 of file define_enum_class.h.

References anonymous_namespace{Utm.h}::N.

Referenced by sort_by_name().

                                                    {
   for (size_t i = 1; i < N; ++i) {
     auto key = arr[i];
     size_t j = i;
     for (; j && key.name < arr[j - 1].name; --j) {
       arr[j] = arr[j - 1];
     }
     arr[j] = key;
   }
 }

Here is the caller graph for this function:

int heavyai::msync	(	void *	addr,
		size_t	length,
		bool	async
	)

Definition at line 57 of file heavyai_fs.cpp.

Referenced by StringDictionary::checkpoint().

                                                  {
   // TODO: support MS_INVALIDATE?
   return ::msync(addr, length, async ? MS_ASYNC : MS_SYNC);
 }

Here is the caller graph for this function:

int heavyai::open	(	const char *	path,
		int	flags,
		int	mode
	)

Definition at line 66 of file heavyai_fs.cpp.

Referenced by TableFunctionsFactory_linker.BaseGenerateFiles::_generate_files(), anonymous_namespace{StringDictionary.cpp}::checked_open(), generate_TableFunctionsFactory_init::find_signatures(), create_table.SyntheticTable::generateData(), TableFunctionsFactory_linker::get_existing_file_content(), heavydb.version::get_source_version(), analyze_benchmark.BenchmarkLoader::load(), make-m2-proxy::main(), run_benchmark::read_query_files(), benchmarks.GoogleBenchmark::run(), benchmarks.TPC_DS_10GB::run(), safe_open(), run_benchmark::send_results_db(), run_benchmark::send_results_file_json(), and run_benchmark::send_results_jenkins_bench().

                                                 {
   return ::open(path, flags, mode);
 }

Here is the caller graph for this function:

bool heavyai::operator!=	(	const UUID &	lhs,
		const UUID &	rhs
	)

inlinenoexcept

Definition at line 102 of file uuid.h.

                                                                   {
   return !(lhs == rhs);
 }

bool heavyai::operator!=	(	const JSON &	json1,
		const JSON &	json2
	)

inline

Definition at line 408 of file json.h.

References heavyai::JSON::vptr_.

                                                              {
   return (*json1.vptr_ != *json2.vptr_);
 }

template<typename T >

bool heavyai::operator!=	(	const JSON &	json,
		const T &	value
	)

inline

Definition at line 424 of file json.h.

References heavyai::JSON::vptr_.

                                                          {
   return (*json.vptr_ != value);
 }

template<typename T >

bool heavyai::operator!=	(	const T &	value,
		const JSON &	json
	)

inline

Definition at line 428 of file json.h.

                                                          {
   return (json != value);
 }

bool heavyai::operator<	(	const UUID &	lhs,
		const UUID &	rhs
	)

inlinenoexcept

Definition at line 106 of file uuid.h.

                                                                  {
   return lhs.data_ < rhs.data_;
 }

bool heavyai::operator==	(	const UUID &	lhs,
		const UUID &	rhs
	)

inlinenoexcept

Definition at line 98 of file uuid.h.

                                                                   {
   return lhs.data_ == rhs.data_;
 }

bool heavyai::operator==	(	const JSON &	json1,
		const JSON &	json2
	)

inline

Definition at line 404 of file json.h.

References heavyai::JSON::vptr_.

                                                              {
   return (*json1.vptr_ == *json2.vptr_);
 }

template<typename T >

bool heavyai::operator==	(	const JSON &	json,
		const T &	value
	)

inline

Definition at line 415 of file json.h.

References heavyai::JSON::vptr_.

                                                          {
   return (*json.vptr_ == value);
 }

template<typename T >

bool heavyai::operator==	(	const T &	value,
		const JSON &	json
	)

inline

Definition at line 419 of file json.h.

                                                          {
   return (json == value);
 }

int32_t heavyai::pclose ( ::FILE * fh )

Definition at line 82 of file heavyai_fs.cpp.

Referenced by anonymous_namespace{UdfCompiler.cpp}::exec_output().

                          {
   return ::pclose(fh);
 }

Here is the caller graph for this function:

FILE * heavyai::popen	(	const char *	command,
		const char *	type
	)

Definition at line 78 of file heavyai_fs.cpp.

Referenced by anonymous_namespace{UdfCompiler.cpp}::exec_output().

                                                    {
   return ::popen(command, type);
 }

Here is the caller graph for this function:

int heavyai::safe_close ( int fd )

noexcept

Definition at line 101 of file heavyai_fs.cpp.

References close(), and UNREACHABLE.

Referenced by CommandLineOptions::validate().

                                 {
   for (int ret;;) {
     ret = ::close(fd);
     if (ret == -1 && errno == EINTR) {  // interrupted by signal
       continue;
     }
     return ret;
   }
   UNREACHABLE();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int heavyai::safe_fcntl	(	int	fd,
		int	cmd,
		struct flock *	fl
	)

noexcept

Definition at line 112 of file heavyai_fs.cpp.

References UNREACHABLE.

Referenced by CommandLineOptions::validate().

                                                            {
   for (int ret;;) {
     ret = ::fcntl(fd, cmd, fl);
     if (ret == -1 && errno == EINTR) {  // interrupted by signal
       continue;
     }
     return ret;
   }
   UNREACHABLE();
 }

Here is the caller graph for this function:

int32_t heavyai::safe_ftruncate	(	const int32_t	fd,
		int64_t	length
	)

noexcept

Definition at line 162 of file heavyai_fs.cpp.

References ftruncate(), and UNREACHABLE.

                                                                   {
   for (int ret;;) {
     ret = ::ftruncate(fd, length);
     if (ret == -1 && errno == EINTR) {  // interrupted by signal
       continue;
     }
     return ret;
   }
   UNREACHABLE();
 }

Here is the call graph for this function:

int heavyai::safe_open	(	const char *	path,
		int	flags,
		mode_t	mode
	)

noexcept

Definition at line 90 of file heavyai_fs.cpp.

References open(), and UNREACHABLE.

Referenced by CommandLineOptions::validate().

                                                                  {
   for (int ret;;) {
     ret = ::open(path, flags, mode);
     if (ret == -1 && errno == EINTR) {  // interrupted by signal
       continue;
     }
     return ret;
   }
   UNREACHABLE();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ssize_t heavyai::safe_read	(	const int	fd,
		void *	buffer,
		const size_t	buffer_size
	)

noexcept

Definition at line 123 of file heavyai_fs.cpp.

References File_Namespace::read(), and UNREACHABLE.

                                                                                  {
   for (ssize_t ret, sz = 0;;) {
     ret = ::read(fd, &static_cast<char*>(buffer)[sz], buffer_size - sz);
     if (ret == -1) {
       if (errno == EINTR) {  // interrupted by signal
         continue;
       }
       return -1;
     }
     if (ret == 0) {  // EOF
       return sz;
     }
     sz += ret;
     if (sz == static_cast<ssize_t>(buffer_size)) {
       return sz;
     }
     // either an EOF is coming or interrupted by signal
   }
   UNREACHABLE();
 }

Here is the call graph for this function:

ssize_t heavyai::safe_write	(	const int	fd,
		const void *	buffer,
		const size_t	buffer_size
	)

noexcept

Definition at line 144 of file heavyai_fs.cpp.

References UNREACHABLE, and File_Namespace::write().

Referenced by CommandLineOptions::validate().

                                                                                         {
   for (ssize_t ret, sz = 0;;) {
     ret = ::write(fd, &static_cast<char const*>(buffer)[sz], buffer_size - sz);
     if (ret == -1) {
       if (errno == EINTR) {  // interrupted by signal
         continue;
       }
       return -1;
     }
     sz += ret;
     if (sz == static_cast<ssize_t>(buffer_size)) {
       return sz;
     }
     // either an error is coming (such as disk full) or interrupted by signal
   }
   UNREACHABLE();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Enum >

constexpr std::array<StringEnum<Enum>, size_t(Enum::N_)> heavyai::sort_by_name ( )

Definition at line 111 of file define_enum_class.h.

References insertion_sort().

                                                                     {
   auto arr = enum_to_array<Enum>(std::make_index_sequence<size_t(Enum::N_)>());
   insertion_sort(arr);
   return arr;
 }

Here is the call graph for this function:

template<typename Enum >

std::optional<Enum> heavyai::to_enum ( std::string_view const name )

Definition at line 119 of file define_enum_class.h.

References gpu_enabled::lower_bound(), and setup::name.

                                                      {
   constexpr std::array<StringEnum<Enum>, size_t(Enum::N_)> arr = sort_by_name<Enum>();
   auto const itr = std::lower_bound(arr.begin(), arr.end(), name);
   bool const found = itr != arr.end() && itr->name == name;
   return found ? std::make_optional(itr->value) : std::nullopt;
 }

Here is the call graph for this function:

std::string heavyai::to_string ( const UUID & uuid )

inline

Definition at line 110 of file uuid.h.

Referenced by enum_to_array().

                                              {
   std::stringstream ss;
   ss << uuid;
   return ss.str();
 }

Here is the caller graph for this function:

Variable Documentation

constexpr UUID heavyai::empty_uuid {}

Definition at line 116 of file uuid.h.

heavyai::GroupByBaselineHash

Definition at line 58 of file enums.h.

heavyai::GroupByPerfectHash

Definition at line 58 of file enums.h.

heavyai::NonGroupedAggregate

Definition at line 58 of file enums.h.

Referenced by ResultSetReductionJIT::codegen(), Executor::collectAllDeviceResults(), anonymous_namespace{GroupByAndAggregate.cpp}::get_expr_range_info(), init_agg_val_vec(), anonymous_namespace{ResultSetReductionJIT.cpp}::is_aggregate_query(), ResultSetStorage::isEmptyEntry(), ResultSetStorage::isEmptyEntryColumnar(), ThriftSerializers::layout_from_thrift(), ThriftSerializers::layout_to_thrift(), TargetExprCodegenBuilder::operator()(), QueryMemoryDescriptor::queryDescTypeToString(), QueryMemoryDescriptor::QueryMemoryDescriptor(), ResultSetStorage::reduce(), ResultSetReductionJIT::reduceOneEntryNoCollisionsIdx(), anonymous_namespace{ResultSetReductionJIT.cpp}::setup_reduce_one_entry(), target_exprs_to_infos(), and QueryMemoryDescriptor::threadsShareMemory().

heavyai::Projection

Definition at line 58 of file enums.h.

Referenced by ResultSetStorage::binSearchRowCount(), QueryMemoryDescriptor::blocksShareMemory(), QueryMemoryDescriptor::canUsePerDeviceCardinality(), GroupByAndAggregate::codegen(), GroupByAndAggregate::codegenAggCalls(), GroupByAndAggregate::codegenAggColumnPtr(), GroupByAndAggregate::codegenGroupBy(), GroupByAndAggregate::codegenOutputSlot(), copy_projection_buffer_from_gpu_columnar(), ResultSetLogicalValuesBuilder::create(), Executor::createKernels(), RelAlgExecutor::executeLogicalValues(), Executor::executeWorkUnitImpl(), anonymous_namespace{GroupByAndAggregate.cpp}::get_expr_range_info(), ArrowResultSetConverter::getArrowBatch(), QueryMemoryDescriptor::getBufferSizeBytes(), anonymous_namespace{GroupByAndAggregate.cpp}::init_count_distinct_descriptors(), QueryMemoryInitializer::initColumnarGroups(), anonymous_namespace{TargetExprBuilder.cpp}::is_columnar_projection(), ResultSet::isDirectColumnarConversionPossible(), ResultSetStorage::isEmptyEntryColumnar(), QueryMemoryDescriptor::isLogicalSizedColumnsAllowed(), ResultSet::isZeroCopyColumnarConversionPossible(), QueryExecutionContext::launchCpuCode(), QueryExecutionContext::launchGpuCode(), ThriftSerializers::layout_from_thrift(), ThriftSerializers::layout_to_thrift(), ColumnarResults::materializeAllColumnsDirectly(), ColumnarResults::materializeAllColumnsProjection(), QueryMemoryDescriptor::queryDescTypeToString(), QueryMemoryDescriptor::QueryMemoryDescriptor(), ResultSet::rowCountImpl(), ExecutionKernel::runImpl(), and ResultSet::updateStorageEntryCount().

heavyai::TableFunction

Definition at line 58 of file enums.h.

Referenced by table_functions::TableFunctionsFactory::add(), TableFunctionManager::allocate_output_buffers(), QueryMemoryDescriptor::blocksShareMemory(), ColumnarResults::copyAllNonLazyColumns(), Executor::executeTableFunction(), ArrowResultSetConverter::getArrowBatch(), QueryMemoryDescriptor::getBufferSizeBytes(), QueryMemoryDescriptor::getColOffInBytes(), anonymous_namespace{TargetExprBuilder.cpp}::is_columnar_projection(), ResultSet::isDirectColumnarConversionPossible(), ResultSetStorage::isEmptyEntryColumnar(), QueryMemoryDescriptor::isLogicalSizedColumnsAllowed(), ResultSet::isZeroCopyColumnarConversionPossible(), TableFunctionExecutionContext::launchGpuCode(), ColumnarResults::materializeAllColumnsDirectly(), ColumnarResults::materializeAllColumnsTableFunction(), ColumnarResults::materializeAllLazyColumns(), QueryMemoryDescriptor::queryDescTypeToString(), QueryMemoryDescriptor::QueryMemoryDescriptor(), ResultSet::rowCountImpl(), synthesize_metadata(), synthesize_metadata_table_function(), and ResultSet::updateStorageEntryCount().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation