21 #include <tbb/parallel_for.h>
22 #include <tbb/task_arena.h>
24 #include <boost/filesystem/operations.hpp>
25 #include <boost/filesystem/path.hpp>
26 #include <boost/sort/spreadsort/string_sort.hpp>
31 #include <string_view>
33 #include <type_traits>
40 #include <sys/fcntl.h>
60 auto fd =
heavyai::open(path, O_RDWR | O_CREAT | (recover ? O_APPEND : O_TRUNC), 0644);
64 auto err = std::string(
"Dictionary path ") + std::string(path) +
65 std::string(
" does not exist.");
82 if (in == 0 || (in > (UINT32_MAX))) {
91 for (
size_t i = 0; i < str.size(); ++i) {
92 str_hash = str_hash * 997 + str[i];
98 int64_t num_threads{0};
102 const int64_t num_elems,
103 const int64_t target_elems_per_thread) {
105 std::min(std::max(max_thread_count, int64_t(1)),
106 ((num_elems + target_elems_per_thread - 1) / target_elems_per_thread));
107 num_elems_per_thread =
108 std::max((num_elems + num_threads - 1) / num_threads, int64_t(1));
120 const std::string& folder,
123 const bool materializeHashes,
124 size_t initial_capacity)
125 : dict_key_(dict_key)
128 , string_id_string_dict_hash_table_(initial_capacity, INVALID_STR_ID)
129 , hash_cache_(initial_capacity)
131 , materialize_hashes_(materializeHashes)
134 , offset_map_(nullptr)
135 , payload_map_(nullptr)
136 , offset_file_size_(0)
137 , payload_file_size_(0)
138 , payload_file_off_(0)
139 , like_cache_size_(0)
140 , regex_cache_size_(0)
141 , equal_cache_size_(0)
142 , compare_cache_size_(0)
143 , strings_cache_(nullptr)
144 , strings_cache_size_(0) {
145 if (!isTemp && folder.empty()) {
150 CHECK_EQ(
size_t(0), (initial_capacity & (initial_capacity - 1)));
152 boost::filesystem::path storage_path(folder);
153 offsets_path_ = (storage_path / boost::filesystem::path(
"DictOffsets")).
string();
154 const auto payload_path =
155 (storage_path / boost::filesystem::path(
"DictPayload")).
string();
161 bool storage_is_empty =
false;
163 storage_is_empty =
true;
179 const uint64_t str_count =
184 const uint64_t max_entries =
186 round_up_p2(std::max(initial_capacity, static_cast<size_t>(1))));
190 std::vector<string_dict_hash_t> new_hash_cache(max_entries / 2);
195 if (str_count == 0) {
199 unsigned string_id = 0;
200 std::lock_guard<std::shared_mutex> write_lock(
rw_mutex_);
202 uint32_t thread_inits = 0;
203 const auto thread_count = std::thread::hardware_concurrency();
204 const uint32_t items_per_thread = std::max<uint32_t>(
205 2000, std::min<uint32_t>(200000, (str_count / thread_count) + 1));
206 std::vector<std::future<std::vector<std::pair<string_dict_hash_t, unsigned int>>>>
208 for (string_id = 0; string_id < str_count; string_id += items_per_thread) {
211 std::vector<std::pair<string_dict_hash_t, unsigned int>> hashVec;
212 for (uint32_t curr_id = string_id;
213 curr_id < string_id + items_per_thread && curr_id < str_count;
216 if (recovered.canary) {
220 std::string_view temp(recovered.c_str_ptr, recovered.size);
221 hashVec.emplace_back(std::make_pair(
hash_string(temp), temp.size()));
227 if (thread_inits % thread_count == 0) {
232 if (dictionary_futures.size() != 0) {
235 VLOG(1) <<
"Opened string dictionary " << folder <<
" # Strings: " <<
str_count_
247 std::unordered_map<std::string, int32_t>
map_;
250 void operator()(std::string
const& str, int32_t
const string_id)
override {
251 auto const emplaced = map_.emplace(str, string_id);
252 CHECK(emplaced.second) <<
"str(" << str <<
") string_id(" << string_id <<
')';
254 void operator()(std::string_view
const, int32_t
const string_id)
override {
255 UNREACHABLE() <<
"MapMaker must be called with a std::string.";
257 std::unordered_map<std::string, int32_t>
moveMap() {
return std::move(map_); }
264 constexpr
size_t big_gen =
static_cast<size_t>(std::numeric_limits<size_t>::max());
267 return [map{map_maker.moveMap()}](std::string
const& str) {
268 auto const itr = map.find(str);
280 CHECK_LE(n, static_cast<size_t>(std::numeric_limits<int32_t>::max()) + 1);
281 for (
unsigned id = 0;
id <
n; ++id) {
283 std::shared_lock<std::shared_mutex> read_lock(
rw_mutex_);
286 serial_callback(str,
id);
289 size_t const n = std::min(static_cast<size_t>(generation),
str_count_);
290 CHECK_LE(n, static_cast<size_t>(std::numeric_limits<int32_t>::max()) + 1);
291 std::shared_lock<std::shared_mutex> read_lock(
rw_mutex_);
292 for (
unsigned id = 0;
id <
n; ++id) {
299 std::vector<std::future<std::vector<std::pair<string_dict_hash_t, unsigned int>>>>&
300 dictionary_futures) {
301 for (
auto& dictionary_future : dictionary_futures) {
302 dictionary_future.wait();
303 const auto hashVec = dictionary_future.get();
304 for (
const auto& hash : hashVec) {
305 const uint32_t bucket =
315 dictionary_futures.clear();
330 const size_t storage_slots)
const noexcept {
331 if (storage_slots == 0) {
336 int64_t min_bound = 0;
337 int64_t max_bound = storage_slots - 1;
339 while (min_bound <= max_bound) {
340 guess = (max_bound + min_bound) / 2;
342 if (getStringFromStorage(guess).canary) {
343 max_bound = guess - 1;
345 min_bound = guess + 1;
348 CHECK_GE(guess + (min_bound > guess ? 1 : 0), 0);
349 return guess + (min_bound > guess ? 1 : 0);
354 : dict_key_(dict_key)
355 , folder_(
"DB_" + std::
to_string(dict_key.db_id) +
"_DICT_" +
357 , strings_cache_(nullptr)
388 std::vector<int32_t> string_ids;
389 client_->get_or_add_bulk(string_ids, std::vector<std::string>{str});
390 CHECK_EQ(
size_t(1), string_ids.size());
391 return string_ids.front();
393 return getOrAddImpl(str);
400 std::ostringstream oss;
401 oss <<
"The text encoded column using dictionary " << dict_key
402 <<
" has exceeded it's limit of " <<
sizeof(
T) * 8 <<
" bits ("
403 << static_cast<size_t>(max_valid_int_value<T>() + 1) <<
" unique values) "
404 <<
"while attempting to add the new string '" << str <<
"'. ";
413 oss <<
"To load more data, please re-create the table with "
414 <<
"this column as type TEXT ENCODING DICT(" <<
sizeof(
T) * 2 * 8 <<
") ";
415 if (
sizeof(
T) == 1) {
416 oss <<
"or TEXT ENCODING DICT(32) ";
418 oss <<
"and reload your data.";
422 oss <<
"Currently dictionary-encoded text columns support a maximum of "
424 <<
" strings. Consider recreating the table with "
425 <<
"this column as type TEXT ENCODING NONE and reloading your data.";
428 throw std::runtime_error(oss.str());
433 std::ostringstream oss;
434 oss <<
"The string '" << str <<
" could not be inserted into the dictionary "
435 << dict_key <<
" because it exceeded the maximum allowable "
437 << str.size() <<
" characters).";
439 throw std::runtime_error(oss.str());
444 template <
class String>
446 const std::vector<std::vector<String>>& string_array_vec,
447 std::vector<std::vector<int32_t>>& ids_array_vec) {
453 ids_array_vec.resize(string_array_vec.size());
454 for (
size_t i = 0; i < string_array_vec.size(); i++) {
455 auto& strings = string_array_vec[i];
456 auto& ids = ids_array_vec[i];
457 ids.resize(strings.size());
463 const std::vector<std::vector<std::string>>& string_array_vec,
464 std::vector<std::vector<int32_t>>& ids_array_vec);
467 const std::vector<std::vector<std::string_view>>& string_array_vec,
468 std::vector<std::vector<int32_t>>& ids_array_vec);
475 template <
class String>
477 const std::vector<String>& string_vec,
478 std::vector<string_dict_hash_t>& hashes)
const noexcept {
479 CHECK_EQ(string_vec.size(), hashes.size());
482 [&string_vec, &hashes](
const tbb::blocked_range<size_t>& r) {
483 for (
size_t curr_id = r.begin(); curr_id != r.end(); ++curr_id) {
484 if (string_vec[curr_id].empty()) {
487 hashes[curr_id] =
hash_string(string_vec[curr_id]);
492 template <
class T,
class String>
494 T* encoded_vec)
const {
495 return getBulk(string_vec, encoded_vec, -1L );
499 uint8_t* encoded_vec)
const;
501 uint16_t* encoded_vec)
const;
503 int32_t* encoded_vec)
const;
505 template <
class T,
class String>
508 const int64_t generation)
const {
509 constexpr int64_t target_strings_per_thread{1000};
510 const int64_t num_lookup_strings = string_vec.size();
511 if (num_lookup_strings == 0) {
516 std::thread::hardware_concurrency(), num_lookup_strings, target_strings_per_thread);
520 std::vector<size_t> num_strings_not_found_per_thread(thread_info.
num_threads, 0UL);
522 std::shared_lock<std::shared_mutex> read_lock(
rw_mutex_);
523 const int64_t num_dict_strings = generation >= 0 ? generation :
storageEntryCount();
524 const bool dictionary_is_empty = (num_dict_strings == 0);
525 if (dictionary_is_empty) {
527 [&](
const tbb::blocked_range<int64_t>& r) {
528 const int64_t start_idx = r.begin();
529 const int64_t end_idx = r.end();
530 for (int64_t string_idx = start_idx; string_idx < end_idx;
535 return num_lookup_strings;
540 tbb::task_arena limited_arena(thread_info.
num_threads);
541 limited_arena.execute([&] {
543 tbb::blocked_range<int64_t>(
545 [&](
const tbb::blocked_range<int64_t>& r) {
546 const int64_t start_idx = r.begin();
547 const int64_t end_idx = r.end();
548 size_t num_strings_not_found = 0;
549 for (int64_t string_idx = start_idx; string_idx != end_idx; ++string_idx) {
550 const auto& input_string = string_vec[string_idx];
551 if (input_string.empty()) {
552 encoded_vec[string_idx] = inline_int_null_value<T>();
564 string_id >= num_dict_strings) {
566 num_strings_not_found++;
569 encoded_vec[string_idx] = string_id;
571 const size_t tbb_thread_idx = tbb::this_task_arena::current_thread_index();
572 num_strings_not_found_per_thread[tbb_thread_idx] = num_strings_not_found;
574 tbb::simple_partitioner());
577 size_t num_strings_not_found = 0;
578 for (int64_t thread_idx = 0; thread_idx < thread_info.num_threads; ++thread_idx) {
579 num_strings_not_found += num_strings_not_found_per_thread[thread_idx];
581 return num_strings_not_found;
585 uint8_t* encoded_vec,
586 const int64_t generation)
const;
588 uint16_t* encoded_vec,
589 const int64_t generation)
const;
591 int32_t* encoded_vec,
592 const int64_t generation)
const;
594 template <
class T,
class String>
596 T* output_string_ids) {
602 std::lock_guard<std::shared_mutex> write_lock(
rw_mutex_);
606 for (
const auto& input_string : input_strings) {
607 if (input_string.empty()) {
608 output_string_ids[idx++] = inline_int_null_value<T>();
614 uint32_t hash_bucket =
622 if (
str_count_ > static_cast<size_t>(max_valid_int_value<T>())) {
623 throw_encoding_error<T>(input_string,
dict_key_);
627 <<
") of Dictionary encoded Strings reached for this column, offset path "
641 const int32_t string_id =
static_cast<int32_t
>(
str_count_);
643 output_string_ids[idx++] = string_id;
646 const size_t num_strings_added =
str_count_ - initial_str_count;
647 if (num_strings_added > 0) {
652 template <
class T,
class String>
654 T* output_string_ids) {
657 std::vector<string_dict_hash_t> input_strings_hashes(input_strings.size());
660 std::lock_guard<std::shared_mutex> write_lock(
rw_mutex_);
661 size_t shadow_str_count =
663 const size_t storage_high_water_mark = shadow_str_count;
664 std::vector<size_t> string_memory_ids;
665 size_t sum_new_string_lengths = 0;
666 string_memory_ids.reserve(input_strings.size());
667 size_t input_string_idx{0};
668 for (
const auto& input_string : input_strings) {
670 if (input_string.empty()) {
671 output_string_ids[input_string_idx++] = inline_int_null_value<T>();
680 storage_high_water_mark,
683 input_strings_hashes);
688 const uint32_t hash_bucket =
692 storage_high_water_mark,
700 output_string_ids[input_string_idx++] =
706 if (shadow_str_count > static_cast<size_t>(max_valid_int_value<T>())) {
707 throw_encoding_error<T>(input_string,
dict_key_);
710 <<
"Maximum number (" << shadow_str_count
711 <<
") of Dictionary encoded Strings reached for this column, offset path "
715 string_memory_ids.push_back(input_string_idx);
716 sum_new_string_lengths += input_string.size();
718 static_cast<int32_t
>(shadow_str_count);
722 output_string_ids[input_string_idx++] = shadow_str_count++;
725 const size_t num_strings_added = shadow_str_count -
str_count_;
726 str_count_ = shadow_str_count;
727 if (num_strings_added > 0) {
732 uint8_t* encoded_vec);
734 uint16_t* encoded_vec);
736 int32_t* encoded_vec);
739 const std::vector<std::string_view>& string_vec,
740 uint8_t* encoded_vec);
742 const std::vector<std::string_view>& string_vec,
743 uint16_t* encoded_vec);
745 const std::vector<std::string_view>& string_vec,
746 int32_t* encoded_vec);
748 template <
class String>
750 std::shared_lock<std::shared_mutex> read_lock(
rw_mutex_);
752 if constexpr (std::is_same_v<std::string, std::decay_t<String>>) {
755 return client_->get(std::string(str));
766 auto str_id = string_id_string_dict_hash_table_[computeBucket(
767 hash, sv, string_id_string_dict_hash_table_)];
772 std::shared_lock<std::shared_mutex> read_lock(
rw_mutex_);
775 client_->get_string(ret, string_id);
782 std::shared_lock<std::shared_mutex> read_lock(
rw_mutex_);
783 CHECK(!
isClient()) <<
"use of this function is unsupported in distributed";
788 CHECK_LT(string_id, static_cast<int32_t>(str_count_));
789 return getStringChecked(string_id);
793 int32_t string_id)
const noexcept {
794 CHECK_LT(string_id, static_cast<int32_t>(str_count_));
795 return getStringViewChecked(string_id);
799 int32_t string_id)
const noexcept {
800 std::shared_lock<std::shared_mutex> read_lock(rw_mutex_);
803 CHECK_LT(string_id, static_cast<int32_t>(str_count_));
804 return getStringBytesChecked(string_id);
808 std::shared_lock<std::shared_mutex> read_lock(
rw_mutex_);
810 return client_->storage_entry_count();
818 const std::string& pattern,
820 const bool is_simple,
824 str.c_str(), str.size(), pattern.c_str(), pattern.size())
831 str.c_str(), str.size(), pattern.c_str(), pattern.size())
843 const bool is_simple,
845 const size_t generation)
const {
846 std::lock_guard<std::shared_mutex> write_lock(
rw_mutex_);
848 return client_->get_like(pattern, icase, is_simple, escape, generation);
850 const auto cache_key = std::make_tuple(pattern, icase, is_simple, escape);
855 std::vector<int32_t>
result;
856 std::vector<std::thread> workers;
859 std::vector<std::vector<int32_t>> worker_results(worker_count);
861 for (
int worker_idx = 0; worker_idx < worker_count; ++worker_idx) {
862 workers.emplace_back([&worker_results,
871 for (
size_t string_id = worker_idx; string_id < generation;
872 string_id += worker_count) {
874 if (
is_like(str, pattern, icase, is_simple, escape)) {
875 worker_results[worker_idx].push_back(string_id);
880 for (
auto& worker : workers) {
883 for (
const auto& worker_result : worker_results) {
884 result.insert(result.end(), worker_result.begin(), worker_result.end());
887 const auto it_ok =
like_cache_.insert(std::make_pair(cache_key, result));
888 like_cache_size_ += (pattern.size() + 3 + (result.size() *
sizeof(int32_t)));
896 std::string comp_operator,
898 std::vector<int32_t>
result;
903 eq_id = eq_id_itr->second;
904 if (comp_operator ==
"=") {
905 result.push_back(eq_id);
907 for (int32_t idx = 0; idx <= cur_size; idx++) {
911 result.push_back(idx);
915 std::vector<std::thread> workers;
918 std::vector<std::vector<int32_t>> worker_results(worker_count);
920 for (
int worker_idx = 0; worker_idx < worker_count; ++worker_idx) {
921 workers.emplace_back(
922 [&worker_results, &pattern, generation, worker_idx, worker_count,
this]() {
923 for (
size_t string_id = worker_idx; string_id < generation;
924 string_id += worker_count) {
926 if (str == pattern) {
927 worker_results[worker_idx].push_back(string_id);
932 for (
auto& worker : workers) {
935 for (
const auto& worker_result : worker_results) {
936 result.insert(result.end(), worker_result.begin(), worker_result.end());
938 if (result.size() > 0) {
939 const auto it_ok =
equal_cache_.insert(std::make_pair(pattern, result[0]));
944 if (comp_operator ==
"<>") {
945 for (int32_t idx = 0; idx <= cur_size; idx++) {
949 result.push_back(idx);
957 const std::string& comp_operator,
958 const size_t generation) {
959 std::lock_guard<std::shared_mutex> write_lock(
rw_mutex_);
961 return client_->get_compare(pattern, comp_operator, generation);
963 std::vector<int32_t> ret;
968 if (comp_operator ==
"=" || comp_operator ==
"<>") {
969 return getEquals(pattern, comp_operator, generation);
977 cache_index = std::make_shared<StringDictionary::compare_cache_value_t>();
982 [
this](decltype(
sorted_cache)::value_type
const&
a, decltype(pattern)& b) {
984 return string_lt(a_str.c_str_ptr, a_str.size, b.c_str(), b.size());
989 cache_index->diff = 1;
993 cache_str.c_str_ptr, cache_str.size, pattern.c_str(), pattern.size())) {
994 cache_index->index = cache_itr -
sorted_cache.begin() - 1;
995 cache_index->diff = 1;
998 cache_index->diff = 0;
1020 if (comp_operator ==
"<") {
1021 size_t idx = cache_index->index;
1022 if (cache_index->diff) {
1023 idx = cache_index->index + 1;
1024 if (cache_index->index == 0 && cache_index->diff > 0) {
1025 idx = cache_index->index;
1028 for (
size_t i = 0; i < idx; i++) {
1039 }
else if (comp_operator ==
"<=") {
1040 size_t idx = cache_index->index + 1;
1041 if (cache_index == 0 && cache_index->diff > 0) {
1042 idx = cache_index->index;
1044 for (
size_t i = 0; i < idx; i++) {
1053 }
else if (comp_operator ==
">") {
1054 size_t idx = cache_index->index + 1;
1055 if (cache_index->index == 0 && cache_index->diff > 0) {
1056 idx = cache_index->index;
1068 }
else if (comp_operator ==
">=") {
1069 size_t idx = cache_index->index;
1070 if (cache_index->diff) {
1071 idx = cache_index->index + 1;
1072 if (cache_index->index == 0 && cache_index->diff > 0) {
1073 idx = cache_index->index;
1079 }
else if (comp_operator ==
"=") {
1080 if (!cache_index->diff) {
1086 }
else if (comp_operator ==
"<>") {
1087 if (!cache_index->diff) {
1088 size_t idx = cache_index->index;
1089 for (
size_t i = 0; i < idx; i++) {
1103 std::runtime_error(
"Unsupported string comparison operator");
1111 const std::string& pattern,
1112 const char escape) {
1113 return regexp_like(str.c_str(), str.size(), pattern.c_str(), pattern.size(), escape);
1120 const size_t generation)
const {
1121 std::lock_guard<std::shared_mutex> write_lock(
rw_mutex_);
1123 return client_->get_regexp_like(pattern, escape, generation);
1125 const auto cache_key = std::make_pair(pattern, escape);
1130 std::vector<int32_t>
result;
1131 std::vector<std::thread> workers;
1134 std::vector<std::vector<int32_t>> worker_results(worker_count);
1136 for (
int worker_idx = 0; worker_idx < worker_count; ++worker_idx) {
1137 workers.emplace_back([&worker_results,
1144 for (
size_t string_id = worker_idx; string_id < generation;
1145 string_id += worker_count) {
1148 worker_results[worker_idx].push_back(string_id);
1153 for (
auto& worker : workers) {
1156 for (
const auto& worker_result : worker_results) {
1157 result.insert(result.end(), worker_result.begin(), worker_result.end());
1159 const auto it_ok =
regex_cache_.insert(std::make_pair(cache_key, result));
1161 CHECK(it_ok.second);
1167 std::lock_guard<std::shared_mutex> write_lock(
rw_mutex_);
1170 throw std::runtime_error(
1171 "copying dictionaries from remote server is not supported yet.");
1180 const bool multithreaded =
str_count_ > 10000;
1181 const auto worker_count =
1182 multithreaded ?
static_cast<size_t>(
cpu_threads()) :
size_t(1);
1184 std::vector<std::vector<std::string>> worker_results(worker_count);
1185 std::vector<size_t> string_size(worker_count, 0);
1186 auto copy = [
this, &string_size](std::vector<std::string>& str_list,
1187 const size_t worker_idx,
1188 const size_t start_id,
1189 const size_t end_id) {
1191 str_list.reserve(end_id - start_id);
1192 for (
size_t string_id = start_id; string_id < end_id; ++string_id) {
1194 string_size[worker_idx] += str.size();
1195 str_list.push_back(str);
1198 if (multithreaded) {
1199 std::vector<std::future<void>> workers;
1200 const auto stride = (
str_count_ + (worker_count - 1)) / worker_count;
1201 for (
size_t worker_idx = 0, start = 0, end = std::min(start + stride,
str_count_);
1202 worker_idx < worker_count && start <
str_count_;
1203 ++worker_idx, start += stride, end = std::min(start + stride, str_count_)) {
1206 std::ref(worker_results[worker_idx]),
1211 for (
auto& worker : workers) {
1215 CHECK_EQ(worker_results.size(), size_t(1));
1219 for (
const auto& worker_result : worker_results) {
1221 strings_cache_->end(), worker_result.begin(), worker_result.end());
1229 return string_id_string_dict_hash_table_.size() <= num_strings * 2;
1240 new_str_ids[bucket] = i;
1248 new_str_ids[bucket] = i;
1254 template <
class String>
1256 const size_t str_count,
1258 const size_t storage_high_water_mark,
1259 const std::vector<String>& input_strings,
1260 const std::vector<size_t>& string_memory_ids,
1261 const std::vector<string_dict_hash_t>& input_strings_hashes) noexcept {
1262 std::vector<int32_t> new_str_ids(string_id_string_dict_hash_table_.size() * 2,
1264 if (materialize_hashes_) {
1265 for (
size_t i = 0; i != str_count; ++i) {
1267 const uint32_t bucket = computeUniqueBucketWithHash(hash, new_str_ids);
1268 new_str_ids[bucket] = i;
1270 hash_cache_.resize(hash_cache_.size() * 2);
1272 for (
size_t storage_idx = 0; storage_idx != storage_high_water_mark; ++storage_idx) {
1273 const auto storage_string = getStringChecked(storage_idx);
1275 const uint32_t bucket = computeUniqueBucketWithHash(hash, new_str_ids);
1276 new_str_ids[bucket] = storage_idx;
1278 for (
size_t memory_idx = 0; memory_idx != string_memory_ids.size(); ++memory_idx) {
1279 const size_t string_memory_id = string_memory_ids[memory_idx];
1280 const uint32_t bucket = computeUniqueBucketWithHash(
1281 input_strings_hashes[string_memory_id], new_str_ids);
1282 new_str_ids[bucket] = storage_high_water_mark + memory_idx;
1285 string_id_string_dict_hash_table_.swap(new_str_ids);
1290 if (str.size() == 0) {
1291 return inline_int_null_value<int32_t>();
1293 CHECK(str.size() <= MAX_STRLEN);
1296 std::shared_lock<std::shared_mutex> read_lock(rw_mutex_);
1297 const uint32_t bucket = computeBucket(hash, str, string_id_string_dict_hash_table_);
1298 if (string_id_string_dict_hash_table_[bucket] != INVALID_STR_ID) {
1299 return string_id_string_dict_hash_table_[bucket];
1302 std::lock_guard<std::shared_mutex> write_lock(rw_mutex_);
1303 if (fillRateIsHigh(str_count_)) {
1305 increaseHashTableCapacity();
1309 const uint32_t bucket = computeBucket(hash, str, string_id_string_dict_hash_table_);
1310 if (string_id_string_dict_hash_table_[bucket] == INVALID_STR_ID) {
1312 <<
"Maximum number (" << str_count_
1313 <<
") of Dictionary encoded Strings reached for this column, offset path "
1316 appendToStorage(str);
1317 string_id_string_dict_hash_table_[bucket] =
static_cast<int32_t
>(str_count_);
1318 if (materialize_hashes_) {
1319 hash_cache_[str_count_] = hash;
1322 invalidateInvertedIndex();
1324 return string_id_string_dict_hash_table_[bucket];
1328 const auto str_canary = getStringFromStorage(string_id);
1329 CHECK(!str_canary.canary);
1330 return std::string(str_canary.c_str_ptr, str_canary.size);
1334 const int string_id)
const noexcept {
1335 const auto str_canary = getStringFromStorage(string_id);
1336 CHECK(!str_canary.canary);
1337 return std::string_view{str_canary.c_str_ptr, str_canary.size};
1341 const int string_id)
const noexcept {
1342 const auto str_canary = getStringFromStorage(string_id);
1343 CHECK(!str_canary.canary);
1344 return std::make_pair(str_canary.c_str_ptr, str_canary.size);
1347 template <
class String>
1350 const String& input_string,
1351 const std::vector<int32_t>& string_id_string_dict_hash_table)
const noexcept {
1352 const size_t string_dict_hash_table_size = string_id_string_dict_hash_table.size();
1353 uint32_t bucket = hash & (string_dict_hash_table_size - 1);
1355 const int32_t candidate_string_id = string_id_string_dict_hash_table[bucket];
1356 if (candidate_string_id ==
1360 if ((materialize_hashes_ && hash == hash_cache_[candidate_string_id]) ||
1361 !materialize_hashes_) {
1362 const auto candidate_string = getStringFromStorageFast(candidate_string_id);
1363 if (input_string.size() == candidate_string.size() &&
1364 !memcmp(input_string.data(), candidate_string.data(), input_string.size())) {
1370 if (++bucket == string_dict_hash_table_size) {
1377 template <
class String>
1380 const String& input_string,
1381 const std::vector<int32_t>& string_id_string_dict_hash_table,
1382 const size_t storage_high_water_mark,
1383 const std::vector<String>& input_strings,
1384 const std::vector<size_t>& string_memory_ids)
const noexcept {
1385 uint32_t bucket = input_string_hash & (string_id_string_dict_hash_table.size() - 1);
1387 const int32_t candidate_string_id = string_id_string_dict_hash_table[bucket];
1388 if (candidate_string_id ==
1392 if (!materialize_hashes_ || (input_string_hash == hash_cache_[candidate_string_id])) {
1393 if (candidate_string_id > 0 &&
1394 static_cast<size_t>(candidate_string_id) >= storage_high_water_mark) {
1397 size_t memory_offset =
1398 static_cast<size_t>(candidate_string_id - storage_high_water_mark);
1399 const String candidate_string = input_strings[string_memory_ids[memory_offset]];
1400 if (input_string.size() == candidate_string.size() &&
1401 !memcmp(input_string.data(), candidate_string.data(), input_string.size())) {
1407 const auto candidate_storage_string =
1408 getStringFromStorageFast(candidate_string_id);
1409 if (input_string.size() == candidate_storage_string.size() &&
1410 !memcmp(input_string.data(),
1411 candidate_storage_string.data(),
1412 input_string.size())) {
1420 if (++bucket == string_id_string_dict_hash_table.size()) {
1429 const std::vector<int32_t>& string_id_string_dict_hash_table) noexcept {
1430 const size_t string_dict_hash_table_size = string_id_string_dict_hash_table.size();
1431 uint32_t bucket = hash & (string_dict_hash_table_size - 1);
1433 if (string_id_string_dict_hash_table[bucket] ==
1439 if (++bucket == string_dict_hash_table_size) {
1447 const size_t write_length) {
1449 const size_t min_capacity_needed =
1466 const size_t write_length) {
1469 const size_t min_capacity_needed =
1485 template <
class String>
1488 checkAndConditionallyIncreasePayloadCapacity(str.size());
1489 memcpy(payload_map_ + payload_file_off_, str.data(), str.size());
1493 payload_file_off_ += str.size();
1495 checkAndConditionallyIncreaseOffsetCapacity(
sizeof(str_meta));
1496 memcpy(offset_map_ + str_count_, &str_meta,
sizeof(str_meta));
1499 template <
class String>
1501 const std::vector<String>& input_strings,
1502 const std::vector<size_t>& string_memory_ids,
1503 const size_t sum_new_strings_lengths) noexcept {
1504 const size_t num_strings = string_memory_ids.size();
1506 checkAndConditionallyIncreasePayloadCapacity(sum_new_strings_lengths);
1507 checkAndConditionallyIncreaseOffsetCapacity(
sizeof(
StringIdxEntry) * num_strings);
1509 for (
size_t i = 0; i < num_strings; ++i) {
1510 const size_t string_idx = string_memory_ids[i];
1511 const String str = input_strings[string_idx];
1512 const size_t str_size(str.size());
1513 memcpy(payload_map_ + payload_file_off_, str.data(), str_size);
1514 StringIdxEntry str_meta{
static_cast<uint64_t
>(payload_file_off_), str_size};
1515 payload_file_off_ += str_size;
1516 memcpy(offset_map_ + str_count_ + i, &str_meta,
sizeof(str_meta));
1521 const int string_id)
const noexcept {
1523 return {payload_map_ + str_meta->
off, str_meta->
size};
1527 const int string_id)
const noexcept {
1534 if (str_meta->
size == 0xffff) {
1536 return {
nullptr, 0,
true};
1538 return {payload_map_ + str_meta->
off, str_meta->
size,
false};
1543 payload_file_size_ += addStorageCapacity(payload_fd_, min_capacity_requested);
1545 payload_map_ =
static_cast<char*
>(
1546 addMemoryCapacity(payload_map_, payload_file_size_, min_capacity_requested));
1552 offset_file_size_ += addStorageCapacity(offset_fd_, min_capacity_requested);
1555 addMemoryCapacity(offset_map_, offset_file_size_, min_capacity_requested));
1561 const size_t min_capacity_requested) noexcept {
1562 const size_t canary_buff_size_to_add =
1566 if (canary_buffer_size < canary_buff_size_to_add) {
1567 CANARY_BUFFER =
static_cast<char*
>(realloc(CANARY_BUFFER, canary_buff_size_to_add));
1568 canary_buffer_size = canary_buff_size_to_add;
1569 CHECK(CANARY_BUFFER);
1570 memset(CANARY_BUFFER, 0xff, canary_buff_size_to_add);
1573 CHECK_NE(lseek(fd, 0, SEEK_END), -1);
1574 const auto write_return =
write(fd, CANARY_BUFFER, canary_buff_size_to_add);
1575 CHECK(write_return > 0 &&
1576 (static_cast<size_t>(write_return) == canary_buff_size_to_add));
1577 return canary_buff_size_to_add;
1582 const size_t min_capacity_requested) noexcept {
1583 const size_t canary_buff_size_to_add =
1586 if (canary_buffer_size < canary_buff_size_to_add) {
1588 reinterpret_cast<char*
>(realloc(CANARY_BUFFER, canary_buff_size_to_add));
1589 canary_buffer_size = canary_buff_size_to_add;
1590 CHECK(CANARY_BUFFER);
1591 memset(CANARY_BUFFER, 0xff, canary_buff_size_to_add);
1593 void* new_addr = realloc(addr, mem_size + canary_buff_size_to_add);
1595 void* write_addr =
reinterpret_cast<void*
>(
static_cast<char*
>(new_addr) + mem_size);
1596 CHECK(memcpy(write_addr, CANARY_BUFFER, canary_buff_size_to_add));
1597 mem_size += canary_buff_size_to_add;
1643 return static_cast<bool>(
client_);
1649 std::vector<int32_t> temp_sorted_cache;
1650 for (
size_t i = cur_cache_size; i <
str_count_; i++) {
1651 temp_sorted_cache.push_back(i);
1663 std::sort(cache.begin(), cache.end(), [
this](int32_t
a, int32_t b) {
1666 return string_lt(a_str.c_str_ptr, a_str.size, b_str.c_str_ptr, b_str.size);
1672 std::vector<int32_t> updated_cache(temp_sorted_cache.size() +
sorted_cache.size());
1673 size_t t_idx = 0, s_idx = 0, idx = 0;
1674 for (; t_idx < temp_sorted_cache.size() && s_idx <
sorted_cache.size(); idx++) {
1677 const auto insert_from_temp_cache =
1678 string_lt(t_string.c_str_ptr, t_string.size, s_string.c_str_ptr, s_string.size);
1679 if (insert_from_temp_cache) {
1680 updated_cache[idx] = temp_sorted_cache[t_idx++];
1685 while (t_idx < temp_sorted_cache.size()) {
1686 updated_cache[idx++] = temp_sorted_cache[t_idx++];
1695 std::vector<int32_t>& dest_ids,
1697 const std::vector<int32_t>& source_ids,
1699 const std::vector<std::string const*>& transient_string_vec) {
1700 std::vector<std::string> strings;
1702 for (
const int32_t source_id : source_ids) {
1703 if (source_id == std::numeric_limits<int32_t>::min()) {
1704 strings.emplace_back(
"");
1705 }
else if (source_id < 0) {
1707 CHECK_LT(string_index, transient_string_vec.size()) <<
"source_id=" << source_id;
1708 strings.emplace_back(*transient_string_vec[string_index]);
1710 strings.push_back(source_dict->
getString(source_id));
1714 dest_ids.resize(strings.size());
1719 std::vector<std::vector<int32_t>>& dest_array_ids,
1721 const std::vector<std::vector<int32_t>>& source_array_ids,
1723 dest_array_ids.resize(source_array_ids.size());
1725 std::atomic<size_t> row_idx{0};
1726 auto processor = [&row_idx, &dest_array_ids, dest_dict, &source_array_ids, source_dict](
1729 auto row = row_idx.fetch_add(1);
1731 if (row >= dest_array_ids.size()) {
1734 const auto& source_ids = source_array_ids[row];
1735 auto& dest_ids = dest_array_ids[row];
1740 const int num_worker_threads = std::thread::hardware_concurrency();
1742 if (source_array_ids.size() / num_worker_threads > 10) {
1743 std::vector<std::future<void>> worker_threads;
1744 for (
int i = 0; i < num_worker_threads; ++i) {
1748 for (
auto& child : worker_threads) {
1751 for (
auto& child : worker_threads) {
1760 const size_t generation)
const {
1762 std::shared_lock<std::shared_mutex> read_lock(
rw_mutex_);
1773 CHECK_LE(num_strings, std::numeric_limits<int32_t>::max());
1775 std::vector<std::string_view> string_views(num_strings);
1777 if (num_strings == 0) {
1778 return string_views;
1780 constexpr int64_t tbb_parallel_threshold{1000};
1781 if (num_strings < tbb_parallel_threshold) {
1783 for (int32_t string_idx = 0; string_idx < num_strings; ++string_idx) {
1787 constexpr int64_t target_strings_per_thread{1000};
1789 std::thread::hardware_concurrency(), num_strings, target_strings_per_thread);
1793 tbb::task_arena limited_arena(thread_info.
num_threads);
1794 limited_arena.execute([&] {
1796 tbb::blocked_range<int64_t>(
1798 [&](
const tbb::blocked_range<int64_t>& r) {
1800 const int32_t start_idx = r.begin();
1801 const int32_t end_idx = r.end();
1802 for (int32_t string_idx = start_idx; string_idx != end_idx; ++string_idx) {
1806 tbb::simple_partitioner());
1809 return string_views;
1817 const std::shared_ptr<StringDictionary> dest_dict,
1821 const size_t num_dest_strings = dest_dict->storageEntryCount();
1822 std::vector<int32_t> translated_ids(num_source_strings);
1825 translated_ids.data(),
1830 dest_transient_lookup_callback,
1832 return translated_ids;
1837 std::shared_lock<std::shared_mutex>& source_read_lock,
1838 std::shared_lock<std::shared_mutex>& dest_read_lock) {
1839 const bool dicts_are_same = (source_dict_key == dest_dict_key);
1840 const bool source_dict_is_locked_first = (source_dict_key < dest_dict_key);
1841 if (dicts_are_same) {
1843 dest_read_lock.lock();
1844 }
else if (source_dict_is_locked_first) {
1845 source_read_lock.lock();
1846 dest_read_lock.lock();
1848 dest_read_lock.lock();
1849 source_read_lock.lock();
1855 int32_t* translated_ids,
1856 const int64_t source_generation,
1857 const int64_t dest_generation,
1858 const bool dest_has_transients,
1860 const std::vector<StringOps_Namespace::StringOpInfo>& string_op_infos)
const {
1864 const int64_t num_source_strings = source_generation;
1865 const int64_t num_dest_strings = dest_generation;
1868 if (num_source_strings == 0L) {
1877 throw std::runtime_error(
1878 "Cannot translate between a local source and remote destination dictionary.");
1883 std::shared_lock<std::shared_mutex> source_read_lock(
rw_mutex_, std::defer_lock);
1884 std::shared_lock<std::shared_mutex> dest_read_lock(dest_dict->
rw_mutex_,
1896 const bool dest_dictionary_is_empty = (num_dest_strings == 0);
1898 constexpr int64_t target_strings_per_thread{1000};
1900 std::thread::hardware_concurrency(), num_source_strings, target_strings_per_thread);
1909 const StringOps_Namespace::StringOps string_ops(string_op_infos);
1910 const bool has_string_ops = string_ops.size();
1912 tbb::task_arena limited_arena(thread_info.
num_threads);
1913 std::vector<size_t> num_strings_not_translated_per_thread(thread_info.
num_threads, 0UL);
1914 constexpr
bool short_circuit_empty_dictionary_translations{
false};
1915 limited_arena.execute([&] {
1916 if (short_circuit_empty_dictionary_translations && dest_dictionary_is_empty) {
1918 tbb::blocked_range<int32_t>(
1922 [&](
const tbb::blocked_range<int32_t>& r) {
1923 const int32_t start_idx = r.begin();
1924 const int32_t end_idx = r.end();
1925 for (int32_t string_idx = start_idx; string_idx != end_idx; ++string_idx) {
1929 tbb::simple_partitioner());
1930 num_strings_not_translated_per_thread[0] += num_source_strings;
1939 tbb::blocked_range<int32_t>(
1943 [&](
const tbb::blocked_range<int32_t>& r) {
1944 const int32_t start_idx = r.begin();
1945 const int32_t end_idx = r.end();
1946 size_t num_strings_not_translated = 0;
1947 std::string string_ops_storage;
1949 for (int32_t source_string_id = start_idx; source_string_id != end_idx;
1950 ++source_string_id) {
1951 const std::string_view source_str =
1956 if (source_str.empty()) {
1957 translated_ids[source_string_id] = inline_int_null_value<int32_t>();
1971 const auto translated_string_id =
1973 translated_ids[source_string_id] = translated_string_id;
1976 translated_string_id >= num_dest_strings) {
1977 if (dest_has_transients) {
1978 num_strings_not_translated +=
1979 dest_transient_lookup_callback(source_str, source_string_id);
1981 num_strings_not_translated++;
1986 const size_t tbb_thread_idx = tbb::this_task_arena::current_thread_index();
1987 num_strings_not_translated_per_thread[tbb_thread_idx] +=
1988 num_strings_not_translated;
1990 tbb::simple_partitioner());
1993 size_t total_num_strings_not_translated = 0;
1994 for (int64_t thread_idx = 0; thread_idx < thread_info.num_threads; ++thread_idx) {
1995 total_num_strings_not_translated += num_strings_not_translated_per_thread[thread_idx];
1997 return total_num_strings_not_translated;
2001 Datum* translated_ids,
2002 const int64_t source_generation,
2003 const std::vector<StringOps_Namespace::StringOpInfo>& string_op_infos)
const {
2006 CHECK_GT(string_op_infos.size(), 0UL);
2007 CHECK(!string_op_infos.back().getReturnType().is_string());
2008 const int64_t num_source_strings = source_generation;
2011 if (num_source_strings == 0L) {
2020 std::shared_lock<std::shared_mutex> source_read_lock(
rw_mutex_);
2029 constexpr int64_t target_strings_per_thread{1000};
2031 std::thread::hardware_concurrency(), num_source_strings, target_strings_per_thread);
2040 const StringOps_Namespace::StringOps string_ops(string_op_infos);
2043 tbb::task_arena limited_arena(thread_info.
num_threads);
2050 limited_arena.execute([&] {
2052 tbb::blocked_range<int32_t>(
2054 [&](
const tbb::blocked_range<int32_t>& r) {
2055 const int32_t start_idx = r.begin();
2056 const int32_t end_idx = r.end();
2057 for (int32_t source_string_id = start_idx; source_string_id != end_idx;
2058 ++source_string_id) {
2059 const std::string source_str =
2061 translated_ids[source_string_id] = string_ops.numericEval(source_str);
2070 const std::vector<int32_t>& source_ids,
2072 const int32_t dest_generation) {
2075 dict_server_host, {temp_dict_key.
db_id, temp_dict_key.
dict_id},
false);
void throw_string_too_long_error(std::string_view str, const shared::StringDictKey &dict_key)
StringIdxEntry * offset_map_
void translate_string_ids(std::vector< int32_t > &dest_ids, const DictRef dest_dict_ref, const std::vector< int32_t > &source_ids, const DictRef source_dict_ref, const int32_t dest_generation)
size_t payload_file_size_
bool isClient() const noexcept
void increaseHashTableCapacity() noexcept
void checkAndConditionallyIncreasePayloadCapacity(const size_t write_length)
string_dict_hash_t hash_string(const std::string_view &str)
size_t addStorageCapacity(int fd, const size_t min_capacity_requested=0) noexcept
std::vector< int32_t > getRegexpLike(const std::string &pattern, const char escape, const size_t generation) const
void operator()(std::string_view const, int32_t const string_id) override
size_t getBulk(const std::vector< String > &string_vec, T *encoded_vec) const
int64_t num_elems_per_thread
client_no_timeout_(new StringDictionaryClient(host,{dict_key.db_id, dict_key.dict_id}, false))
std::vector< int32_t > buildDictionaryTranslationMap(const std::shared_ptr< StringDictionary > dest_dict, StringLookupCallback const &dest_transient_lookup_callback) const
RUNTIME_EXPORT DEVICE bool string_eq(const char *lhs, const int32_t lhs_len, const char *rhs, const int32_t rhs_len)
std::vector< std::string > copyStrings() const
void buildDictionaryNumericTranslationMap(Datum *translated_ids, const int64_t source_generation, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos) const
const shared::StringDictKey & getDictKey() const noexcept
std::pair< char *, size_t > getStringBytesChecked(const int string_id) const noexcept
size_t storageEntryCount() const
StringDictionary(const shared::StringDictKey &dict_key, const std::string &folder, const bool isTemp, const bool recover, const bool materializeHashes=false, size_t initial_capacity=256)
void addOffsetCapacity(const size_t min_capacity_requested=0) noexcept
uint32_t computeBucketFromStorageAndMemory(const string_dict_hash_t input_string_hash, const String &input_string, const std::vector< int32_t > &string_id_string_dict_hash_table, const size_t storage_high_water_mark, const std::vector< String > &input_strings, const std::vector< size_t > &string_memory_ids) const noexcept
std::string getStringChecked(const int string_id) const noexcept
std::vector< string_dict_hash_t > hash_cache_
DictionaryCache< std::string, compare_cache_value_t > compare_cache_
DEVICE void sort(ARGS &&...args)
bool fillRateIsHigh(const size_t num_strings) const noexcept
void * addMemoryCapacity(void *addr, size_t &mem_size, const size_t min_capacity_requested=0) noexcept
Constants for Builtin SQL Types supported by HEAVY.AI.
std::string offsets_path_
static void populate_string_ids(std::vector< int32_t > &dest_ids, StringDictionary *dest_dict, const std::vector< int32_t > &source_ids, const StringDictionary *source_dict, const std::vector< std::string const * > &transient_string_vec={})
Populates provided dest_ids vector with string ids corresponding to given source strings.
std::unordered_map< std::string, int32_t > map_
std::shared_mutex rw_mutex_
std::string_view getStringFromStorageFast(const int string_id) const noexcept
int32_t getOrAdd(const std::string &str) noexcept
std::map< std::pair< std::string, char >, std::vector< int32_t > > regex_cache_
size_t computeCacheSize() const
std::unique_ptr< StringDictionaryClient > client_
std::string getStringUnlocked(int32_t string_id) const noexcept
size_t write(FILE *f, const size_t offset, const size_t size, const int8_t *buf)
Writes the specified number of bytes to the offset position in file f from buf.
RUNTIME_EXPORT DEVICE bool string_lt(const char *lhs, const int32_t lhs_len, const char *rhs, const int32_t rhs_len)
int32_t getIdOfString(const String &) const
bool is_regexp_like(const std::string &str, const std::string &pattern, const char escape)
std::string_view getStringView(int32_t string_id) const
static constexpr size_t MAX_STRCOUNT
std::vector< int32_t > getEquals(std::string pattern, std::string comp_operator, size_t generation)
uint32_t computeBucket(const string_dict_hash_t hash, const String &input_string, const std::vector< int32_t > &string_id_string_dict_hash_table) const noexcept
size_t compare_cache_size_
future< Result > async(Fn &&fn, Args &&...args)
static constexpr int32_t INVALID_STR_ID
std::shared_ptr< std::vector< std::string > > strings_cache_
std::vector< int32_t > getCompare(const std::string &pattern, const std::string &comp_operator, const size_t generation)
DEVICE auto copy(ARGS &&...args)
int open(const char *path, int flags, int mode)
RUNTIME_EXPORT DEVICE bool string_like(const char *str, const int32_t str_len, const char *pattern, const int32_t pat_len, const char escape_char)
void appendToStorageBulk(const std::vector< String > &input_strings, const std::vector< size_t > &string_memory_ids, const size_t sum_new_strings_lengths) noexcept
RUNTIME_EXPORT DEVICE bool string_like_simple(const char *str, const int32_t str_len, const char *pattern, const int32_t pat_len)
void addPayloadCapacity(const size_t min_capacity_requested=0) noexcept
bool is_like(const std::string &str, const std::string &pattern, const bool icase, const bool is_simple, const char escape)
std::map< std::string, int32_t > equal_cache_
DEVICE auto accumulate(ARGS &&...args)
void order_translation_locks(const shared::StringDictKey &source_dict_key, const shared::StringDictKey &dest_dict_key, std::shared_lock< std::shared_mutex > &source_read_lock, std::shared_lock< std::shared_mutex > &dest_read_lock)
uint32_t computeUniqueBucketWithHash(const string_dict_hash_t hash, const std::vector< int32_t > &string_id_string_dict_hash_table) noexcept
void getOrAddBulkArray(const std::vector< std::vector< String >> &string_array_vec, std::vector< std::vector< int32_t >> &ids_array_vec)
Functions to support the LIKE and ILIKE operator in SQL. Only single-byte character set is supported ...
int32_t getUnlocked(const std::string_view sv) const noexcept
void appendToStorage(const String str) noexcept
int checked_open(const char *path, const bool recover)
void getOrAddBulk(const std::vector< String > &string_vec, T *encoded_vec)
const shared::StringDictKey dict_key_
std::unordered_map< std::string, int32_t > moveMap()
std::pair< char *, size_t > getStringBytes(int32_t string_id) const noexcept
void processDictionaryFutures(std::vector< std::future< std::vector< std::pair< string_dict_hash_t, unsigned int >>>> &dictionary_futures)
void translate_string_ids(std::vector< int32_t > &dest_ids, const LeafHostInfo &dict_server_host, const shared::StringDictKey &dest_dict_key, const std::vector< int32_t > &source_ids, const shared::StringDictKey &source_dict_key, const int32_t dest_generation)
const int SYSTEM_PAGE_SIZE
bool checkpoint() noexcept
void throw_encoding_error(std::string_view str, const shared::StringDictKey &dict_key)
std::vector< int32_t > getLike(const std::string &pattern, const bool icase, const bool is_simple, const char escape, const size_t generation) const
void mergeSortedCache(std::vector< int32_t > &temp_sorted_cache)
DEVICE auto lower_bound(ARGS &&...args)
void eachStringSerially(int64_t const generation, StringCallback &) const
RUNTIME_EXPORT DEVICE bool string_ilike_simple(const char *str, const int32_t str_len, const char *pattern, const int32_t pat_len)
size_t getNumStringsFromStorage(const size_t storage_slots) const noexcept
void update_leaf(const LeafHostInfo &host_info)
size_t strings_cache_size_
int64_t num_elems_per_thread
std::string getString(int32_t string_id) const
void hashStrings(const std::vector< String > &string_vec, std::vector< string_dict_hash_t > &hashes) const noexcept
std::vector< std::string_view > getStringViews() const
int msync(void *addr, size_t length, bool async)
std::unique_ptr< StringDictionaryClient > client_no_timeout_
void parallel_for(const blocked_range< Int > &range, const Body &body, const Partitioner &p=Partitioner())
void increaseHashTableCapacityFromStorageAndMemory(const size_t str_count, const size_t storage_high_water_mark, const std::vector< String > &input_strings, const std::vector< size_t > &string_memory_ids, const std::vector< string_dict_hash_t > &input_strings_hashes) noexcept
std::function< int32_t(std::string const &)> makeLambdaStringToId() const
void checkAndConditionallyIncreaseOffsetCapacity(const size_t write_length)
static void populate_string_array_ids(std::vector< std::vector< int32_t >> &dest_array_ids, StringDictionary *dest_dict, const std::vector< std::vector< int32_t >> &source_array_ids, const StringDictionary *source_dict)
void invalidateInvertedIndex() noexcept
uint32_t string_dict_hash_t
#define DEBUG_TIMER(name)
void checked_munmap(void *addr, size_t length)
const uint64_t round_up_p2(const uint64_t num)
std::string_view getStringViewUnlocked(int32_t string_id) const noexcept
std::vector< int32_t > string_id_string_dict_hash_table_
ThreadInfo(const int64_t max_thread_count, const int64_t num_elems, const int64_t target_elems_per_thread)
void sortCache(std::vector< int32_t > &cache)
std::string_view getStringViewChecked(const int string_id) const noexcept
static constexpr size_t MAX_STRLEN
void getOrAddBulkParallel(const std::vector< String > &string_vec, T *encoded_vec)
std::function< bool(std::string_view, int32_t string_id)> StringLookupCallback
std::map< std::tuple< std::string, bool, bool, char >, std::vector< int32_t > > like_cache_
bool g_enable_stringdict_parallel
PayloadString getStringFromStorage(const int string_id) const noexcept
RUNTIME_EXPORT DEVICE bool regexp_like(const char *str, const int32_t str_len, const char *pattern, const int32_t pat_len, const char escape_char)
size_t file_size(const int fd)
static unsigned transientIdToIndex(int32_t const id)
void operator()(std::string const &str, int32_t const string_id) override
DEVICE void swap(ARGS &&...args)
std::vector< int32_t > sorted_cache
int32_t getOrAddImpl(const std::string_view &str) noexcept
~StringDictionary() noexcept
void * checked_mmap(const int fd, const size_t sz)
RUNTIME_EXPORT DEVICE bool string_ilike(const char *str, const int32_t str_len, const char *pattern, const int32_t pat_len, const char escape_char)