diff --git a/src/trace_processor/db/query_executor.cc b/src/trace_processor/db/query_executor.cc
index 056a8db..d0ef7ed 100644
--- a/src/trace_processor/db/query_executor.cc
+++ b/src/trace_processor/db/query_executor.cc
@@ -66,12 +66,12 @@
   }
 
   switch (storage.ValidateSearchConstraints(c.value, c.op)) {
-    case storage::Storage::SearchValidationResult::kAllData:
+    case SearchValidationResult::kAllData:
       return;
-    case storage::Storage::SearchValidationResult::kNoData:
+    case SearchValidationResult::kNoData:
       rm->Clear();
       return;
-    case storage::Storage::SearchValidationResult::kOk:
+    case SearchValidationResult::kOk:
       break;
   }
 
@@ -291,12 +291,12 @@
                                                   const storage::Storage& col,
                                                   RowMap* rm) {
   switch (col.ValidateSearchConstraints(c.value, c.op)) {
-    case storage::Storage::SearchValidationResult::kAllData:
+    case SearchValidationResult::kAllData:
       return;
-    case storage::Storage::SearchValidationResult::kNoData:
+    case SearchValidationResult::kNoData:
       rm->Clear();
       return;
-    case storage::Storage::SearchValidationResult::kOk:
+    case SearchValidationResult::kOk:
       break;
   }
 
@@ -307,12 +307,12 @@
                                                   const storage::Storage& col,
                                                   RowMap* rm) {
   switch (col.ValidateSearchConstraints(c.value, c.op)) {
-    case storage::Storage::SearchValidationResult::kAllData:
+    case SearchValidationResult::kAllData:
       return;
-    case storage::Storage::SearchValidationResult::kNoData:
+    case SearchValidationResult::kNoData:
       rm->Clear();
       return;
-    case storage::Storage::SearchValidationResult::kOk:
+    case SearchValidationResult::kOk:
       break;
   }
 
diff --git a/src/trace_processor/db/storage/arrangement_storage.cc b/src/trace_processor/db/storage/arrangement_storage.cc
index fac7f68..703e4b7 100644
--- a/src/trace_processor/db/storage/arrangement_storage.cc
+++ b/src/trace_processor/db/storage/arrangement_storage.cc
@@ -40,7 +40,7 @@
                   inner_->size());
 }
 
-Storage::SearchValidationResult ArrangementStorage::ValidateSearchConstraints(
+SearchValidationResult ArrangementStorage::ValidateSearchConstraints(
     SqlValue sql_val,
     FilterOp op) const {
   return inner_->ValidateSearchConstraints(sql_val, op);
diff --git a/src/trace_processor/db/storage/arrangement_storage.h b/src/trace_processor/db/storage/arrangement_storage.h
index 97a944e..2f0ac10 100644
--- a/src/trace_processor/db/storage/arrangement_storage.h
+++ b/src/trace_processor/db/storage/arrangement_storage.h
@@ -32,8 +32,8 @@
   explicit ArrangementStorage(std::unique_ptr<Storage> inner,
                               const std::vector<uint32_t>* arrangement);
 
-  Storage::SearchValidationResult ValidateSearchConstraints(SqlValue, FilterOp)
-      const override;
+  SearchValidationResult ValidateSearchConstraints(SqlValue,
+                                                   FilterOp) const override;
 
   RangeOrBitVector Search(FilterOp op,
                           SqlValue value,
diff --git a/src/trace_processor/db/storage/dense_null_storage.cc b/src/trace_processor/db/storage/dense_null_storage.cc
index e1a6d69..cbe9743 100644
--- a/src/trace_processor/db/storage/dense_null_storage.cc
+++ b/src/trace_processor/db/storage/dense_null_storage.cc
@@ -32,11 +32,11 @@
                                    const BitVector* non_null)
     : inner_(std::move(inner)), non_null_(non_null) {}
 
-Storage::SearchValidationResult DenseNullStorage::ValidateSearchConstraints(
+SearchValidationResult DenseNullStorage::ValidateSearchConstraints(
     SqlValue sql_val,
     FilterOp op) const {
   if (op == FilterOp::kIsNull) {
-    return Storage::SearchValidationResult::kOk;
+    return SearchValidationResult::kOk;
   }
 
   return inner_->ValidateSearchConstraints(sql_val, op);
@@ -49,7 +49,7 @@
 
   if (op == FilterOp::kIsNull) {
     switch (inner_->ValidateSearchConstraints(sql_val, op)) {
-      case Storage::SearchValidationResult::kNoData: {
+      case SearchValidationResult::kNoData: {
         // There is no need to search in underlying storage. It's enough to
         // intersect the |non_null_|.
         BitVector res = non_null_->IntersectRange(in.start, in.end);
@@ -57,9 +57,9 @@
         res.Resize(in.end, false);
         return RangeOrBitVector(std::move(res));
       }
-      case Storage::SearchValidationResult::kAllData:
+      case SearchValidationResult::kAllData:
         return RangeOrBitVector(in);
-      case Storage::SearchValidationResult::kOk:
+      case SearchValidationResult::kOk:
         break;
     }
   }
diff --git a/src/trace_processor/db/storage/dummy_storage.cc b/src/trace_processor/db/storage/dummy_storage.cc
index b4f0be5..ed30e8d 100644
--- a/src/trace_processor/db/storage/dummy_storage.cc
+++ b/src/trace_processor/db/storage/dummy_storage.cc
@@ -21,9 +21,8 @@
 namespace trace_processor {
 namespace storage {
 
-DummyStorage::SearchValidationResult DummyStorage::ValidateSearchConstraints(
-    SqlValue,
-    FilterOp) const {
+SearchValidationResult DummyStorage::ValidateSearchConstraints(SqlValue,
+                                                               FilterOp) const {
   PERFETTO_FATAL("Shouldn't be called");
 }
 
diff --git a/src/trace_processor/db/storage/fake_storage.cc b/src/trace_processor/db/storage/fake_storage.cc
index fd9ac2c..9d2316a 100644
--- a/src/trace_processor/db/storage/fake_storage.cc
+++ b/src/trace_processor/db/storage/fake_storage.cc
@@ -27,9 +27,8 @@
 FakeStorage::FakeStorage(uint32_t size, SearchStrategy strategy)
     : size_(size), strategy_(strategy) {}
 
-FakeStorage::SearchValidationResult FakeStorage::ValidateSearchConstraints(
-    SqlValue,
-    FilterOp) const {
+SearchValidationResult FakeStorage::ValidateSearchConstraints(SqlValue,
+                                                              FilterOp) const {
   return SearchValidationResult::kOk;
 }
 
diff --git a/src/trace_processor/db/storage/id_storage.cc b/src/trace_processor/db/storage/id_storage.cc
index 36418f9..68cfb2f 100644
--- a/src/trace_processor/db/storage/id_storage.cc
+++ b/src/trace_processor/db/storage/id_storage.cc
@@ -74,9 +74,8 @@
 
 }  // namespace
 
-IdStorage::SearchValidationResult IdStorage::ValidateSearchConstraints(
-    SqlValue val,
-    FilterOp op) const {
+SearchValidationResult IdStorage::ValidateSearchConstraints(SqlValue val,
+                                                            FilterOp op) const {
   // NULL checks.
   if (PERFETTO_UNLIKELY(val.is_null())) {
     if (op == FilterOp::kIsNotNull) {
@@ -118,11 +117,11 @@
     case SqlValue::kString:
       // Any string is always more than any numeric.
       if (op == FilterOp::kLt || op == FilterOp::kLe) {
-        return Storage::SearchValidationResult::kAllData;
+        return SearchValidationResult::kAllData;
       }
-      return Storage::SearchValidationResult::kNoData;
+      return SearchValidationResult::kNoData;
     case SqlValue::kBytes:
-      return Storage::SearchValidationResult::kNoData;
+      return SearchValidationResult::kNoData;
   }
 
   // TODO(b/307482437): Remove after adding support for double
diff --git a/src/trace_processor/db/storage/id_storage_unittest.cc b/src/trace_processor/db/storage/id_storage_unittest.cc
index e792c01..91cc37b 100644
--- a/src/trace_processor/db/storage/id_storage_unittest.cc
+++ b/src/trace_processor/db/storage/id_storage_unittest.cc
@@ -38,55 +38,55 @@
 
   // NULL checks
   ASSERT_EQ(storage.ValidateSearchConstraints(SqlValue(), FilterOp::kIsNull),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(SqlValue(), FilterOp::kIsNotNull),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   // FilterOp checks
   ASSERT_EQ(
       storage.ValidateSearchConstraints(SqlValue::Long(15), FilterOp::kGlob),
-      Storage::SearchValidationResult::kNoData);
+      SearchValidationResult::kNoData);
   ASSERT_EQ(
       storage.ValidateSearchConstraints(SqlValue::Long(15), FilterOp::kRegex),
-      Storage::SearchValidationResult::kNoData);
+      SearchValidationResult::kNoData);
 
   // Type checks
   ASSERT_EQ(storage.ValidateSearchConstraints(SqlValue::String("cheese"),
                                               FilterOp::kGe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 
   // Value bounds
   SqlValue max_val = SqlValue::Long(
       static_cast<int64_t>(std::numeric_limits<uint32_t>::max()) + 10);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kGe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kGt),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kEq),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kLe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kLt),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kNe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   SqlValue min_val = SqlValue::Long(
       static_cast<int64_t>(std::numeric_limits<uint32_t>::min()) - 1);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kGe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kGt),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kNe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kLe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kLt),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kEq),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 }
 
 TEST(IdStorageUnittest, SearchEqSimple) {
diff --git a/src/trace_processor/db/storage/null_storage.cc b/src/trace_processor/db/storage/null_storage.cc
index 44e2061..a1ca7d0 100644
--- a/src/trace_processor/db/storage/null_storage.cc
+++ b/src/trace_processor/db/storage/null_storage.cc
@@ -73,11 +73,11 @@
 
 }  // namespace
 
-Storage::SearchValidationResult NullStorage::ValidateSearchConstraints(
+SearchValidationResult NullStorage::ValidateSearchConstraints(
     SqlValue sql_val,
     FilterOp op) const {
   if (op == FilterOp::kIsNull) {
-    return Storage::SearchValidationResult::kOk;
+    return SearchValidationResult::kOk;
   }
 
   return storage_->ValidateSearchConstraints(sql_val, op);
@@ -96,7 +96,7 @@
 
   if (op == FilterOp::kIsNull) {
     switch (storage_->ValidateSearchConstraints(sql_val, op)) {
-      case Storage::SearchValidationResult::kNoData: {
+      case SearchValidationResult::kNoData: {
         // There is no need to search in underlying storage. It's enough to
         // intersect the |non_null_|.
         BitVector res = non_null_->IntersectRange(in.start, in.end);
@@ -104,9 +104,9 @@
         res.Resize(non_null_->size(), false);
         return RangeOrBitVector(std::move(res));
       }
-      case Storage::SearchValidationResult::kAllData:
+      case SearchValidationResult::kAllData:
         return RangeOrBitVector(in);
-      case Storage::SearchValidationResult::kOk:
+      case SearchValidationResult::kOk:
         break;
     }
   }
@@ -129,7 +129,7 @@
 
   if (op == FilterOp::kIsNull) {
     switch (storage_->ValidateSearchConstraints(sql_val, op)) {
-      case Storage::SearchValidationResult::kNoData: {
+      case SearchValidationResult::kNoData: {
         BitVector::Builder null_indices(indices_size);
         for (uint32_t* it = indices; it != indices + indices_size; it++) {
           null_indices.Append(!non_null_->IsSet(*it));
@@ -138,9 +138,9 @@
         // check if the index is set in |non_null_|.
         return RangeOrBitVector(std::move(null_indices).Build());
       }
-      case Storage::SearchValidationResult::kAllData:
+      case SearchValidationResult::kAllData:
         return RangeOrBitVector(Range(0, indices_size));
-      case Storage::SearchValidationResult::kOk:
+      case SearchValidationResult::kOk:
         break;
     }
   }
diff --git a/src/trace_processor/db/storage/numeric_storage.cc b/src/trace_processor/db/storage/numeric_storage.cc
index 1857eee..b090cb8 100644
--- a/src/trace_processor/db/storage/numeric_storage.cc
+++ b/src/trace_processor/db/storage/numeric_storage.cc
@@ -195,8 +195,9 @@
 
 }  // namespace
 
-NumericStorageBase::SearchValidationResult
-NumericStorageBase::ValidateSearchConstraints(SqlValue val, FilterOp op) const {
+SearchValidationResult NumericStorageBase::ValidateSearchConstraints(
+    SqlValue val,
+    FilterOp op) const {
   // NULL checks.
   if (PERFETTO_UNLIKELY(val.is_null())) {
     if (op == FilterOp::kIsNotNull) {
@@ -237,11 +238,11 @@
     case SqlValue::kString:
       // Any string is always more than any numeric.
       if (op == FilterOp::kLt || op == FilterOp::kLe) {
-        return Storage::SearchValidationResult::kAllData;
+        return SearchValidationResult::kAllData;
       }
-      return Storage::SearchValidationResult::kNoData;
+      return SearchValidationResult::kNoData;
     case SqlValue::kBytes:
-      return Storage::SearchValidationResult::kNoData;
+      return SearchValidationResult::kNoData;
   }
 
   // TODO(b/307482437): There is currently no support for comparison with double
@@ -289,7 +290,7 @@
 
   switch (extreme_validator) {
     case kOk:
-      return Storage::SearchValidationResult::kOk;
+      return SearchValidationResult::kOk;
     case kTooBig:
       if (op == FilterOp::kLt || op == FilterOp::kLe || op == FilterOp::kNe) {
         return SearchValidationResult::kAllData;
diff --git a/src/trace_processor/db/storage/numeric_storage_unittest.cc b/src/trace_processor/db/storage/numeric_storage_unittest.cc
index aa2d2d7..5ba32ad 100644
--- a/src/trace_processor/db/storage/numeric_storage_unittest.cc
+++ b/src/trace_processor/db/storage/numeric_storage_unittest.cc
@@ -42,22 +42,22 @@
 
   // NULL checks
   ASSERT_EQ(storage.ValidateSearchConstraints(SqlValue(), FilterOp::kIsNull),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(SqlValue(), FilterOp::kIsNotNull),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   // FilterOp checks
   ASSERT_EQ(
       storage.ValidateSearchConstraints(SqlValue::Long(15), FilterOp::kGlob),
-      Storage::SearchValidationResult::kNoData);
+      SearchValidationResult::kNoData);
   ASSERT_EQ(
       storage.ValidateSearchConstraints(SqlValue::Long(15), FilterOp::kRegex),
-      Storage::SearchValidationResult::kNoData);
+      SearchValidationResult::kNoData);
 
   // Type checks
   ASSERT_EQ(storage.ValidateSearchConstraints(SqlValue::String("cheese"),
                                               FilterOp::kGe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 }
 
 TEST(NumericStorageUnittest, InvalidValueBoundsUint32) {
@@ -68,34 +68,34 @@
   SqlValue max_val = SqlValue::Long(
       static_cast<int64_t>(std::numeric_limits<uint32_t>::max()) + 10);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kGe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kGt),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kEq),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kLe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kLt),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kNe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   SqlValue min_val = SqlValue::Long(
       static_cast<int64_t>(std::numeric_limits<uint32_t>::min()) - 1);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kGe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kGt),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kNe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kLe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kLt),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kEq),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 }
 
 TEST(NumericStorageUnittest, InvalidValueBoundsInt32) {
@@ -106,34 +106,34 @@
   SqlValue max_val = SqlValue::Long(
       static_cast<int64_t>(std::numeric_limits<int32_t>::max()) + 10);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kGe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kGt),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kEq),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kLe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kLt),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kNe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   SqlValue min_val = SqlValue::Long(
       static_cast<int64_t>(std::numeric_limits<int32_t>::min()) - 1);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kGe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kGt),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kNe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kLe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kLt),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kEq),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 }
 
 TEST(NumericStorageUnittest, StableSortTrivial) {
diff --git a/src/trace_processor/db/storage/selector_storage.cc b/src/trace_processor/db/storage/selector_storage.cc
index 934b900..d4865e7 100644
--- a/src/trace_processor/db/storage/selector_storage.cc
+++ b/src/trace_processor/db/storage/selector_storage.cc
@@ -31,7 +31,7 @@
                                  const BitVector* selector)
     : inner_(std::move(inner)), selector_(selector) {}
 
-Storage::SearchValidationResult SelectorStorage::ValidateSearchConstraints(
+SearchValidationResult SelectorStorage::ValidateSearchConstraints(
     SqlValue sql_val,
     FilterOp op) const {
   return inner_->ValidateSearchConstraints(sql_val, op);
diff --git a/src/trace_processor/db/storage/selector_storage.h b/src/trace_processor/db/storage/selector_storage.h
index 9d368e2..518e22b 100644
--- a/src/trace_processor/db/storage/selector_storage.h
+++ b/src/trace_processor/db/storage/selector_storage.h
@@ -31,8 +31,8 @@
  public:
   SelectorStorage(std::unique_ptr<Storage> storage, const BitVector* non_null);
 
-  Storage::SearchValidationResult ValidateSearchConstraints(SqlValue, FilterOp)
-      const override;
+  SearchValidationResult ValidateSearchConstraints(SqlValue,
+                                                   FilterOp) const override;
 
   RangeOrBitVector Search(FilterOp op,
                           SqlValue value,
diff --git a/src/trace_processor/db/storage/set_id_storage.cc b/src/trace_processor/db/storage/set_id_storage.cc
index b703644..5efc45f 100644
--- a/src/trace_processor/db/storage/set_id_storage.cc
+++ b/src/trace_processor/db/storage/set_id_storage.cc
@@ -58,7 +58,7 @@
 
 }  // namespace
 
-SetIdStorage::SearchValidationResult SetIdStorage::ValidateSearchConstraints(
+SearchValidationResult SetIdStorage::ValidateSearchConstraints(
     SqlValue val,
     FilterOp op) const {
   // NULL checks.
@@ -101,11 +101,11 @@
     case SqlValue::kString:
       // Any string is always more than any numeric.
       if (op == FilterOp::kLt || op == FilterOp::kLe) {
-        return Storage::SearchValidationResult::kAllData;
+        return SearchValidationResult::kAllData;
       }
-      return Storage::SearchValidationResult::kNoData;
+      return SearchValidationResult::kNoData;
     case SqlValue::kBytes:
-      return Storage::SearchValidationResult::kNoData;
+      return SearchValidationResult::kNoData;
   }
 
   // TODO(b/307482437): Remove after adding support for double
diff --git a/src/trace_processor/db/storage/set_id_storage_unittest.cc b/src/trace_processor/db/storage/set_id_storage_unittest.cc
index b6f6cdb..562db61 100644
--- a/src/trace_processor/db/storage/set_id_storage_unittest.cc
+++ b/src/trace_processor/db/storage/set_id_storage_unittest.cc
@@ -34,55 +34,55 @@
   SetIdStorage storage(&storage_data);
   // NULL checks
   ASSERT_EQ(storage.ValidateSearchConstraints(SqlValue(), FilterOp::kIsNull),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(SqlValue(), FilterOp::kIsNotNull),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   // FilterOp checks
   ASSERT_EQ(
       storage.ValidateSearchConstraints(SqlValue::Long(15), FilterOp::kGlob),
-      Storage::SearchValidationResult::kNoData);
+      SearchValidationResult::kNoData);
   ASSERT_EQ(
       storage.ValidateSearchConstraints(SqlValue::Long(15), FilterOp::kRegex),
-      Storage::SearchValidationResult::kNoData);
+      SearchValidationResult::kNoData);
 
   // Type checks
   ASSERT_EQ(storage.ValidateSearchConstraints(SqlValue::String("cheese"),
                                               FilterOp::kGe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 
   // Value bounds
   SqlValue max_val = SqlValue::Long(
       static_cast<int64_t>(std::numeric_limits<uint32_t>::max()) + 10);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kGe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kGt),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kEq),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kLe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kLt),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(max_val, FilterOp::kNe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   SqlValue min_val = SqlValue::Long(
       static_cast<int64_t>(std::numeric_limits<uint32_t>::min()) - 1);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kGe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kGt),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kNe),
-            Storage::SearchValidationResult::kAllData);
+            SearchValidationResult::kAllData);
 
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kLe),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kLt),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
   ASSERT_EQ(storage.ValidateSearchConstraints(min_val, FilterOp::kEq),
-            Storage::SearchValidationResult::kNoData);
+            SearchValidationResult::kNoData);
 }
 
 TEST(SetIdStorageUnittest, SearchEqSimple) {
diff --git a/src/trace_processor/db/storage/storage.h b/src/trace_processor/db/storage/storage.h
index e2cf237..eb0c52a 100644
--- a/src/trace_processor/db/storage/storage.h
+++ b/src/trace_processor/db/storage/storage.h
@@ -33,8 +33,6 @@
  public:
   using StorageProto = protos::pbzero::SerializedColumn_Storage;
 
-  enum class SearchValidationResult { kOk = 0, kAllData = 1, kNoData = 2 };
-
   virtual ~Storage();
 
   // Verifies whether any further filtering is needed and if not, whether the
@@ -59,7 +57,7 @@
   // Notes for callers:
   //  * Should only be called if ValidateSearchContraints returned kOk.
   //  * Callers should note that the return value of this function corresponds
-  //    to positions in |indices| *not* positions in the storage.
+  //    to positions in the storage.
   //
   // Notes for implementors:
   //  * Implementations should ensure that the return value *only* includes
diff --git a/src/trace_processor/db/storage/string_storage.cc b/src/trace_processor/db/storage/string_storage.cc
index 229e470..7d2bc64 100644
--- a/src/trace_processor/db/storage/string_storage.cc
+++ b/src/trace_processor/db/storage/string_storage.cc
@@ -163,7 +163,7 @@
 
 }  // namespace
 
-StringStorage::SearchValidationResult StringStorage::ValidateSearchConstraints(
+SearchValidationResult StringStorage::ValidateSearchConstraints(
     SqlValue val,
     FilterOp op) const {
   // Type checks.
@@ -175,11 +175,11 @@
     case SqlValue::kDouble:
       // Any string is always more than any numeric.
       if (op == FilterOp::kGt || op == FilterOp::kGe) {
-        return Storage::SearchValidationResult::kAllData;
+        return SearchValidationResult::kAllData;
       }
-      return Storage::SearchValidationResult::kNoData;
+      return SearchValidationResult::kNoData;
     case SqlValue::kBytes:
-      return Storage::SearchValidationResult::kNoData;
+      return SearchValidationResult::kNoData;
   }
 
   return SearchValidationResult::kOk;
diff --git a/src/trace_processor/db/storage/types.h b/src/trace_processor/db/storage/types.h
index 6884988..83c5d01 100644
--- a/src/trace_processor/db/storage/types.h
+++ b/src/trace_processor/db/storage/types.h
@@ -23,6 +23,13 @@
 namespace perfetto {
 namespace trace_processor {
 
+// Result of calling Storage::ValidateSearchResult function.
+enum class SearchValidationResult {
+  kOk = 0,       // It makes sense to run search
+  kAllData = 1,  // Don't run search, all data passes the constraint.
+  kNoData = 2    // Don't run search, no data passes the constraint.
+};
+
 // Used for result of filtering, which is sometimes (for more optimised
 // operations) a Range and BitVector otherwise. Stores a variant of Range and
 // BitVector.
diff --git a/src/trace_processor/db/storage/utils.h b/src/trace_processor/db/storage/utils.h
index 55e18f8..3d38545 100644
--- a/src/trace_processor/db/storage/utils.h
+++ b/src/trace_processor/db/storage/utils.h
@@ -16,7 +16,10 @@
 #ifndef SRC_TRACE_PROCESSOR_DB_STORAGE_UTILS_H_
 #define SRC_TRACE_PROCESSOR_DB_STORAGE_UTILS_H_
 
+#include "perfetto/base/logging.h"
+#include "perfetto/trace_processor/basic_types.h"
 #include "src/trace_processor/containers/bit_vector.h"
+#include "src/trace_processor/db/storage/types.h"
 
 namespace perfetto {
 namespace trace_processor {
@@ -83,6 +86,12 @@
   }
 }
 
+// Used for comparing the integer column ({u|}int{32|64}) with a double value.
+// If further search is required it would return kOk and change the SqlValue to
+// a `SqlLong` which would return real results.
+SearchValidationResult CompareIntColumnWithDouble(SqlValue* sql_val,
+                                                  FilterOp op);
+
 }  // namespace utils
 
 }  // namespace storage