Merge branch 'unstable' into add-ubsan-support

apache · May 11, 2024 · c9df7f9 · c9df7f9
2 parents df89995 + 1e23484
commit c9df7f9
Show file tree

Hide file tree

Showing 5 changed files with 51 additions and 9 deletions.
diff --git a/src/cluster/redis_slot.cc b/src/cluster/redis_slot.cc
@@ -20,8 +20,6 @@
 
 #include "redis_slot.h"
 
-#include <stdlib.h>
-
 #include <algorithm>
 #include <cstdlib>
 #include <string>

diff --git a/src/search/executors/filter_executor.h b/src/search/executors/filter_executor.h
@@ -100,6 +100,9 @@ struct QueryExprEvaluator {
         return l > r;
       case NumericCompareExpr::GET:
         return l >= r;
+      default:
+        CHECK(false) << "unreachable";
+        __builtin_unreachable();
     }
   }
 };

diff --git a/src/search/interval.h b/src/search/interval.h
@@ -128,11 +128,32 @@ struct IntervalSet {
   }
 
   friend IntervalSet operator&(const IntervalSet &l, const IntervalSet &r) {
-    if (l.IsEmpty() || r.IsEmpty()) {
-      return IntervalSet();
+    IntervalSet result;
+
+    if (l.intervals.empty() || r.intervals.empty()) {
+      return result;
+    }
+
+    auto it_l = l.intervals.begin();
+    auto it_r = r.intervals.begin();
+
+    while (it_l != l.intervals.end() && it_r != r.intervals.end()) {
+      // Find overlap between current intervals
+      double start = std::max(it_l->first, it_r->first);
+      double end = std::min(it_l->second, it_r->second);
+
+      if (start <= end) {
+        result.intervals.emplace_back(start, end);
+      }
+
+      if (it_l->second < it_r->second) {
+        ++it_l;
+      } else {
+        ++it_r;
+      }
     }
 
-    return ~(~l | ~r);
+    return result;
   }
 
   friend IntervalSet operator|(const IntervalSet &l, const IntervalSet &r) {

diff --git a/src/storage/rdb_ziplist.cc b/src/storage/rdb_ziplist.cc
@@ -196,7 +196,7 @@ uint32_t ZipList::ZipStoreEntryEncoding(unsigned char *p, size_t zl_size, unsign
     buf[3] = (rawlen >> 8) & 0xff;
     buf[4] = rawlen & 0xff;
   }
-  assert(zl_size >= zlHeaderSize + len);
+  assert(zl_size >= static_cast<size_t>(zlHeaderSize) + len);
   /* Store this length at p. */
   memcpy(p, buf, len);
   return len;

diff --git a/tests/cppunit/interval_test.cc b/tests/cppunit/interval_test.cc
@@ -48,6 +48,14 @@ TEST(IntervalSet, Simple) {
             (IntervalSet::DataType{{IntervalSet::minf, 1}, {4, IntervalSet::inf}}));
   ASSERT_EQ((IntervalSet(NumericCompareExpr::GET, 4) | IntervalSet(NumericCompareExpr::NE, 1)).intervals,
             (IntervalSet::DataType{{IntervalSet::minf, 1}, {IntervalSet::NextNum(1), IntervalSet::inf}}));
+
+  ASSERT_TRUE((IntervalSet(Interval(1, 2)) & IntervalSet(Interval(3, 4))).IsEmpty());
+  ASSERT_EQ((IntervalSet(Interval(1, 2)) & IntervalSet(Interval(2, 4))).intervals, (IntervalSet::DataType{{2, 2}}));
+  ASSERT_EQ((IntervalSet(Interval(1, 3)) & IntervalSet(Interval(2, 4))).intervals, (IntervalSet::DataType{{2, 3}}));
+  ASSERT_EQ((IntervalSet(Interval(3, 8)) & (IntervalSet(Interval(1, 4)) | IntervalSet(Interval(5, 7)))).intervals,
+            (IntervalSet::DataType{{3, 4}, {5, 7}}));
+  ASSERT_EQ((IntervalSet(Interval(3, 8)) & (IntervalSet(Interval(1, 4)) | IntervalSet(Interval(9, 11)))).intervals,
+            (IntervalSet::DataType{{3, 4}}));
   ASSERT_EQ((IntervalSet(NumericCompareExpr::GET, 1) & IntervalSet(NumericCompareExpr::LT, 4)).intervals,
             (IntervalSet::DataType{{1, 4}}));
   ASSERT_EQ((IntervalSet(NumericCompareExpr::GET, 1) & IntervalSet(NumericCompareExpr::NE, 4)).intervals,
@@ -60,9 +68,21 @@ TEST(IntervalSet, Simple) {
             IntervalSet({2, 5}) | IntervalSet({7, 8}));
   ASSERT_EQ(~IntervalSet({2, 8}), IntervalSet({IntervalSet::minf, 2}) | IntervalSet({8, IntervalSet::inf}));
 
-  for (auto i = 0; i < 1000; ++i) {
-    auto gen = [] { return static_cast<double>(rand()) / 100; };
-    auto geni = [&gen] { return IntervalSet({gen(), gen()}); };
+  for (auto i = 0; i < 2000; ++i) {
+    auto gen = [] { return static_cast<double>(std::rand()) / 100; };
+    auto geni = [&gen] {
+      auto r = std::rand() % 50;
+      if (r == 0) {
+        return IntervalSet(NumericCompareExpr::GET, gen());
+      } else if (r == 1) {
+        return IntervalSet(NumericCompareExpr::LT, gen());
+      } else if (r == 2) {
+        return IntervalSet(NumericCompareExpr::NE, gen());
+      } else {
+        return IntervalSet({gen(), gen()});
+      }
+    };
+
     auto l = geni(), r = geni();
     for (int j = 0; j < i % 10; ++j) {
       l = l | geni();