Support nested dictionaries in StringDictionary::eachStringSerially.

Signed-off-by: ienkovich <[email protected]>

Author: ienkovich

omniscidb/StringDictionary/StringDictionary.cpp

@@ -144,15 +144,23 @@ class MapMaker : public StringDictionary::StringCallback {
 // Call serial_callback for each (string/_view, string_id). Must be called serially.
 void StringDictionary::eachStringSerially(int64_t const generation,
                                           StringCallback& serial_callback) const {
-  CHECK(!base_dict_) << "Not implemented";
-  size_t const n = std::min(static_cast<size_t>(generation), str_count_);
+  if (base_dict_) {
+    auto generation_for_base =
+        generation >= 0 ? std::min(generation, base_generation_) : base_generation_;
+    base_dict_->eachStringSerially(generation_for_base, serial_callback);
+  }
+  size_t const n = std::min(static_cast<size_t>(generation), entryCount());
   CHECK_LE(n, static_cast<size_t>(std::numeric_limits<int32_t>::max()) + 1);
   mapd_shared_lock<mapd_shared_mutex> read_lock(rw_mutex_);
-  for (unsigned id = 0; id < n; ++id) {
+  for (unsigned id = base_generation_; id < n; ++id) {
     serial_callback(getStringFromStorageFast(static_cast<int>(id)), id);
   }
 }
 
+void StringDictionary::eachStringSerially(StringCallback& serial_callback) const {
+  eachStringSerially(-1, serial_callback);
+}
+
 int32_t StringDictionary::getDbId() const noexcept {
   return dict_ref_.dbId;
 }

omniscidb/StringDictionary/StringDictionary.h

@@ -99,6 +99,7 @@ class StringDictionary {
   // Each std::string const& (if isClient()) or std::string_view (if !isClient())
   // plus string_id is passed to the callback functor.
   void eachStringSerially(int64_t const generation, StringCallback&) const;
+  void eachStringSerially(StringCallback&) const;
   friend class ::StringLocalCallback;
 
   int32_t getOrAdd(const std::string_view& str) noexcept;

omniscidb/Tests/StringDictionaryTest.cpp

@@ -624,6 +624,61 @@ TEST(NestedStringDictionary, GetTransientBulk) {
   }
 }
 
+class CheckStringsCallback : public StringDictionary::StringCallback {
+ public:
+  CheckStringsCallback(std::set<std::string> expected) : expected_(expected) {}
+
+  void operator()(std::string const& str, int32_t const string_id) override {
+    ASSERT_TRUE(expected_.count(str));
+    expected_.erase(str);
+  }
+
+  void operator()(std::string_view const sv, int32_t const string_id) override {
+    this->operator()(std::string(sv), string_id);
+  }
+
+  bool empty() const { return expected_.empty(); }
+
+ private:
+  std::set<std::string> expected_;
+};
+
+TEST(NestedStringDictionary, EachStringSerially) {
+  auto dict1 =
+      std::make_shared<StringDictionary>(DictRef{-1, 1}, -1, g_cache_string_hash);
+  ASSERT_EQ(dict1->getOrAdd("str1"), 0);
+  ASSERT_EQ(dict1->getOrAdd("str2"), 1);
+  ASSERT_EQ(dict1->getOrAdd("str3"), 2);
+  auto dict2 = std::make_shared<StringDictionary>(dict1, -1, g_cache_string_hash);
+  ASSERT_EQ(dict1->getOrAdd("str4"), 3);
+  ASSERT_EQ(dict2->getOrAdd("str5"), 3);
+  ASSERT_EQ(dict2->getOrAdd("str6"), 4);
+
+  {
+    CheckStringsCallback callback({"str1"s, "str2"s, "str3"s, "str4"});
+    dict1->eachStringSerially(callback);
+    ASSERT_TRUE(callback.empty());
+  }
+
+  {
+    CheckStringsCallback callback({"str1"s, "str2"s, "str3"s, "str5", "str6"s});
+    dict2->eachStringSerially(callback);
+    ASSERT_TRUE(callback.empty());
+  }
+
+  {
+    CheckStringsCallback callback({"str1"s, "str2"s, "str3"s, "str5"});
+    dict2->eachStringSerially(4, callback);
+    ASSERT_TRUE(callback.empty());
+  }
+
+  {
+    CheckStringsCallback callback({"str1"s, "str2"s});
+    dict2->eachStringSerially(2, callback);
+    ASSERT_TRUE(callback.empty());
+  }
+}
+
 TEST(StringDictionaryProxy, BuildIntersectionTranslationMapToOtherProxy) {
   // Use existing dictionary from GetBulk
   const DictRef dict_ref1(-1, 1);