Support nested dictionaries in StringDictionary::getLike.

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

Author: ienkovich

omniscidb/StringDictionary/StringDictionary.cpp

@@ -693,20 +693,30 @@ std::vector<int32_t> StringDictionary::getLike(const std::string& pattern,
                                                const bool icase,
                                                const bool is_simple,
                                                const char escape,
-                                               const size_t generation) const {
-  CHECK(!base_dict_) << "Not implemented";
+                                               int64_t generation) const {
+  generation = generation >= 0 ? std::min(generation, static_cast<int64_t>(entryCount()))
+                               : static_cast<int64_t>(entryCount());
   mapd_lock_guard<mapd_shared_mutex> write_lock(rw_mutex_);
-  const auto cache_key = std::make_tuple(pattern, icase, is_simple, escape);
+  const auto cache_key = std::make_tuple(pattern, icase, is_simple, escape, generation);
   const auto it = like_cache_.find(cache_key);
   if (it != like_cache_.end()) {
     return it->second;
   }
+
   std::vector<int32_t> result;
+  if (base_dict_) {
+    result = base_dict_->getLike(
+        pattern, icase, is_simple, escape, std::min(generation, base_generation_));
+  }
+
+  if (generation < base_generation_) {
+    return result;
+  }
+
   std::vector<std::thread> workers;
   int worker_count = cpu_threads();
   CHECK_GT(worker_count, 0);
   std::vector<std::vector<int32_t>> worker_results(worker_count);
-  CHECK_LE(generation, str_count_);
   for (int worker_idx = 0; worker_idx < worker_count; ++worker_idx) {
     workers.emplace_back([&worker_results,
                           &pattern,
@@ -717,7 +727,7 @@ std::vector<int32_t> StringDictionary::getLike(const std::string& pattern,
                           worker_idx,
                           worker_count,
                           this]() {
-      for (size_t string_id = worker_idx; string_id < generation;
+      for (int string_id = indexToId(worker_idx); string_id < generation;
            string_id += worker_count) {
         const auto str = getStringUnlocked(string_id);
         if (is_like(str, pattern, icase, is_simple, escape)) {

omniscidb/StringDictionary/StringDictionary.h

@@ -126,7 +126,7 @@ class StringDictionary {
                                const bool icase,
                                const bool is_simple,
                                const char escape,
-                               const size_t generation) const;
+                               int64_t generation = -1) const;
 
   std::vector<int32_t> getCompare(const std::string& pattern,
                                   const std::string& comp_operator,
@@ -251,7 +251,8 @@ class StringDictionary {
   size_t payload_file_size_;
   size_t payload_file_off_;
   mutable mapd_shared_mutex rw_mutex_;
-  mutable std::map<std::tuple<std::string, bool, bool, char>, std::vector<int32_t>>
+  mutable std::map<std::tuple<std::string, bool, bool, char, int64_t>,
+                   std::vector<int32_t>>
       like_cache_;
   mutable std::map<std::pair<std::string, char>, std::vector<int32_t>> regex_cache_;
   mutable std::map<std::string, int32_t> equal_cache_;

omniscidb/Tests/StringDictionaryTest.cpp

@@ -741,6 +741,37 @@ TEST(NestedStringDictionary, CopyStringsParallel) {
   ASSERT_EQ(dict1->copyStrings(), strings2);
 }
 
+TEST(NestedStringDictionary, IsLike) {
+  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);
+
+  ASSERT_EQ(dict1->getLike("str%", true, false, '\\'), std::vector<int>({0, 1, 2}));
+  ASSERT_EQ(dict1->getLike("str%", true, false, '\\', 2), std::vector<int>({0, 1}));
+  ASSERT_EQ(dict1->getLike("str[124]", true, false, '\\'), std::vector<int>({0, 1}));
+
+  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);
+
+  ASSERT_EQ(dict1->getLike("str%", true, false, '\\'), std::vector<int>({0, 1, 2, 3}));
+  ASSERT_EQ(dict1->getLike("str%", true, false, '\\', 2), std::vector<int>({0, 1}));
+  ASSERT_EQ(dict1->getLike("str[124]", true, false, '\\'), std::vector<int>({0, 1, 3}));
+
+  ASSERT_EQ(dict2->getLike("str%", true, false, '\\'), std::vector<int>({0, 1, 2, 3, 4}));
+  ASSERT_EQ(dict2->getLike("str%", true, false, '\\', 2), std::vector<int>({0, 1}));
+  ASSERT_EQ(dict2->getLike("str[12467]", true, false, '\\'), std::vector<int>({0, 1, 4}));
+
+  ASSERT_EQ(dict1->getOrAdd("str6"), 4);
+  ASSERT_EQ(dict2->getOrAdd("str7"), 5);
+
+  ASSERT_EQ(dict2->getLike("str[12467]", true, false, '\\'),
+            std::vector<int>({0, 1, 4, 5}));
+}
+
 TEST(StringDictionaryProxy, BuildIntersectionTranslationMapToOtherProxy) {
   // Use existing dictionary from GetBulk
   const DictRef dict_ref1(-1, 1);