diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6b8359a1c09..9f69418e1f4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -169,12 +169,13 @@ if (MSVC)
   add_compile_definitions("$<IF:$<CONFIG:Debug>,DEBUG,NDEBUG>")
   add_compile_options(
     # /Od: Disable optimizations
-    # /bigobj: Increase number of sections in .obj file
-    "$<$<CONFIG:Debug>:/Od;/bigobj>"
+    "$<$<CONFIG:Debug>:/Od>"
     # /Ox: Enable most speed optimizations
     "$<$<CONFIG:Release,RelWithDebInfo>:/Ox>"
     # /Zi: Generate debug info in a separate .pdb file
     "$<$<CONFIG:Debug,RelWithDebInfo>:/Zi>")
+  # /bigobj: increase number of sections in .obj file
+  add_compile_options("/bigobj")
 else()
   add_compile_options(-Wall -Wextra)
   if (TILEDB_WERROR)
diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc
index 2a2307d780c..9cbacc31310 100644
--- a/test/src/unit-sparse-global-order-reader.cc
+++ b/test/src/unit-sparse-global-order-reader.cc
@@ -31,6 +31,7 @@
  */
 
 #include "test/support/rapidcheck/array_templates.h"
+#include "test/support/rapidcheck/query_condition.h"
 #include "test/support/src/array_helpers.h"
 #include "test/support/src/array_templates.h"
 #include "test/support/src/error_helpers.h"
@@ -43,6 +44,7 @@
 #include "tiledb/sm/enums/datatype.h"
 #include "tiledb/sm/misc/comparators.h"
 #include "tiledb/sm/misc/types.h"
+#include "tiledb/sm/query/ast/query_ast.h"
 #include "tiledb/sm/query/readers/result_tile.h"
 #include "tiledb/sm/query/readers/sparse_global_order_reader.h"
 
@@ -78,11 +80,14 @@ using Subarray2DType = std::vector<std::pair<
     std::optional<templates::Domain<D2>>>>;
 
 namespace rc {
-Gen<std::vector<templates::Domain<int>>> make_subarray_1d(
-    const templates::Domain<int>& domain);
+
+template <DimensionType D>
+Gen<std::vector<templates::Domain<D>>> make_subarray_1d(
+    const templates::Domain<D>& domain);
 
 Gen<Subarray2DType<int, int>> make_subarray_2d(
     const templates::Domain<int>& d1, const templates::Domain<int>& d2);
+
 }  // namespace rc
 
 /* ********************************* */
@@ -92,11 +97,12 @@ Gen<Subarray2DType<int, int>> make_subarray_2d(
 /**
  * Options for configuring the CSparseGlobalFx default 1D array
  */
+template <Datatype DIMENSION_TYPE = Datatype::INT32>
 struct DefaultArray1DConfig {
   uint64_t capacity_;
   bool allow_dups_;
 
-  templates::Dimension<Datatype::INT32> dimension_;
+  templates::Dimension<DIMENSION_TYPE> dimension_;
 
   DefaultArray1DConfig()
       : capacity_(2)
@@ -116,17 +122,31 @@ struct DefaultArray1DConfig {
 /**
  * An instance of one-dimension array input to `CSparseGlobalOrderFx::run`
  */
+template <
+    Datatype DIMENSION_TYPE = Datatype::INT32,
+    Datatype ATTR_TYPE = Datatype::INT32,
+    Datatype... ATTR_TYPES>
 struct FxRun1D {
-  using FragmentType = templates::Fragment1D<int, int>;
+  using CoordType = tiledb::type::datatype_traits<DIMENSION_TYPE>::value_type;
+
+  using FragmentType = templates::Fragment1D<
+      CoordType,
+      typename tiledb::type::datatype_traits<ATTR_TYPE>::value_type,
+      typename tiledb::type::datatype_traits<ATTR_TYPES>::value_type...>;
+
+  static constexpr Datatype DimensionType = DIMENSION_TYPE;
 
   uint64_t num_user_cells;
   std::vector<FragmentType> fragments;
 
   // NB: for now this always has length 1, global order query does not
   // support multi-range subarray
-  std::vector<templates::Domain<int>> subarray;
+  std::vector<templates::Domain<CoordType>> subarray;
 
-  DefaultArray1DConfig array;
+  // for evaluating
+  std::optional<tdb_unique_ptr<tiledb::sm::ASTNode>> condition;
+
+  DefaultArray1DConfig<DIMENSION_TYPE> array;
   SparseGlobalOrderReaderMemoryBudget memory;
 
   uint64_t tile_capacity() const {
@@ -163,11 +183,11 @@ struct FxRun1D {
   /**
    * @return true if the cell at index `record` in `fragment` passes `subarray`
    */
-  bool accept(const FragmentType& fragment, int record) const {
+  bool pass_subarray(const FragmentType& fragment, int record) const {
     if (subarray.empty()) {
       return true;
     } else {
-      const int coord = fragment.dim_[record];
+      const CoordType coord = fragment.dim_[record];
       for (const auto& range : subarray) {
         if (range.contains(coord)) {
           return true;
@@ -183,8 +203,8 @@ struct FxRun1D {
   bool intersects(const sm::NDRange& mbr) const {
     auto accept = [&](const auto& range) {
       const auto& untyped_mbr = mbr[0];
-      const templates::Domain<int> typed_mbr(
-          untyped_mbr.start_as<int>(), untyped_mbr.end_as<int>());
+      const templates::Domain<CoordType> typed_mbr(
+          untyped_mbr.start_as<CoordType>(), untyped_mbr.end_as<CoordType>());
       return range.intersects(typed_mbr);
     };
     return subarray.empty() ||
@@ -200,7 +220,7 @@ struct FxRun1D {
       return mbr;
     }
     assert(subarray.size() == 1);
-    if (subarray[0].upper_bound < mbr[0].end_as<int>()) {
+    if (subarray[0].upper_bound < mbr[0].end_as<CoordType>()) {
       // in this case, the bitmap will filter out the other coords in the
       // tile and it will be discarded
       return std::vector<type::Range>{subarray[0].range()};
@@ -209,13 +229,15 @@ struct FxRun1D {
     }
   }
 
-  std::tuple<const templates::Dimension<Datatype::INT32>&> dimensions() const {
-    return std::tuple<const templates::Dimension<Datatype::INT32>&>(
+  std::tuple<const templates::Dimension<DIMENSION_TYPE>&> dimensions() const {
+    return std::tuple<const templates::Dimension<DIMENSION_TYPE>&>(
         array.dimension_);
   }
 
-  std::tuple<Datatype> attributes() const {
-    return std::make_tuple(Datatype::INT32);
+  std::vector<Datatype> attributes() const {
+    std::vector<Datatype> a = {ATTR_TYPE};
+    (a.push_back(ATTR_TYPES), ...);
+    return a;
   }
 };
 
@@ -229,6 +251,7 @@ struct FxRun2D {
       std::optional<templates::Domain<Coord0Type>>,
       std::optional<templates::Domain<Coord1Type>>>>
       subarray;
+  std::optional<tdb_unique_ptr<tiledb::sm::ASTNode>> condition;
 
   size_t num_user_cells;
 
@@ -316,8 +339,8 @@ struct FxRun2D {
   /**
    * @return true if the cell at index `record` in `fragment` passes `subarray`
    */
-  bool accept(const FragmentType& fragment, int record) const {
-    if (subarray.empty()) {
+  bool pass_subarray(const FragmentType& fragment, int record) const {
+    if (subarray.empty() && !condition.has_value()) {
       return true;
     } else {
       const int r = fragment.d1_[record], c = fragment.d2_[record];
@@ -387,8 +410,8 @@ struct FxRun2D {
     return CoordsRefType(d1, d2);
   }
 
-  std::tuple<Datatype> attributes() const {
-    return std::make_tuple(Datatype::INT32);
+  std::vector<Datatype> attributes() const {
+    return {Datatype::INT32};
   }
 };
 
@@ -406,10 +429,12 @@ concept InstanceType = requires(const T& instance) {
   instance.fragments;
   instance.memory;
   instance.subarray;
+  instance.condition;
   instance.dimensions();
   instance.attributes();
 
-  // also `accept(Self::FragmentType, int)`, unclear how to represent that
+  // also `pass_subarray(Self::FragmentType, int)`, unclear how to represent
+  // that
 };
 
 struct CSparseGlobalOrderFx {
@@ -427,7 +452,7 @@ struct CSparseGlobalOrderFx {
 
   template <typename Asserter = tiledb::test::AsserterCatch>
   void create_default_array_1d(
-      const DefaultArray1DConfig& config = DefaultArray1DConfig());
+      const DefaultArray1DConfig<>& config = DefaultArray1DConfig<>());
 
   void create_default_array_1d_strings(bool allow_dups = false);
 
@@ -536,7 +561,7 @@ void CSparseGlobalOrderFx::update_config() {
 
 template <typename Asserter>
 void CSparseGlobalOrderFx::create_default_array_1d(
-    const DefaultArray1DConfig& config) {
+    const DefaultArray1DConfig<>& config) {
   tiledb::test::create_array(
       context(),
       array_name_,
@@ -1267,7 +1292,8 @@ TEST_CASE_METHOD(
                   size_t num_user_cells,
                   int extent,
                   const std::vector<templates::Domain<int>>& subarray =
-                      std::vector<templates::Domain<int>>()) {
+                      std::vector<templates::Domain<int>>(),
+                  tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
     // Write a fragment F0 with unique coordinates
     templates::Fragment1D<int, int> fragment0;
     fragment0.dim_.resize(fragment_size);
@@ -1291,7 +1317,7 @@ TEST_CASE_METHOD(
     f1atts.resize(fragment1.dim_.size());
     std::iota(f1atts.begin(), f1atts.end(), int(fragment0.dim_.size()));
 
-    struct FxRun1D instance;
+    FxRun1D instance;
     instance.fragments.push_back(fragment0);
     instance.fragments.push_back(fragment1);
     instance.num_user_cells = num_user_cells;
@@ -1303,14 +1329,24 @@ TEST_CASE_METHOD(
     instance.memory.ratio_array_data_ = "0.5";
 
     instance.subarray = subarray;
+    if (condition) {
+      instance.condition.emplace(std::move(condition));
+    }
 
-    run<Asserter, FxRun1D>(instance);
+    run<Asserter>(instance);
   };
 
   SECTION("Example") {
     doit.operator()<tiledb::test::AsserterCatch>(200, 8, 2);
   }
 
+  SECTION("Condition") {
+    int value = 110;
+    tdb_unique_ptr<tiledb::sm::ASTNode> qc(new tiledb::sm::ASTNodeVal(
+        "a1", &value, sizeof(int), tiledb::sm::QueryConditionOp::GE));
+    doit.operator()<tiledb::test::AsserterCatch>(200, 8, 2, {}, std::move(qc));
+  }
+
   SECTION("Shrink", "Some examples found by rapidcheck") {
     doit.operator()<tiledb::test::AsserterCatch>(
         2, 1, 1, {templates::Domain<int>(1, 1)});
@@ -1327,8 +1363,15 @@ TEST_CASE_METHOD(
       const int extent = *rc::gen::inRange(1, 200);
       const auto subarray =
           *rc::make_subarray_1d(templates::Domain<int>(1, 200));
+      auto condition =
+          *rc::make_query_condition<FxRun1D<>::FragmentType>(std::make_tuple(
+              templates::Domain<int>(1, 200), templates::Domain<int>(0, 400)));
       doit.operator()<tiledb::test::AsserterRapidcheck>(
-          fragment_size, num_user_cells, extent, subarray);
+          fragment_size,
+          num_user_cells,
+          extent,
+          subarray,
+          std::move(condition));
     });
   }
 }
@@ -1352,7 +1395,8 @@ TEST_CASE_METHOD(
   auto doit = [this]<typename Asserter>(
                   size_t fragment_size,
                   size_t num_user_cells,
-                  const std::vector<templates::Domain<int>>& subarray = {}) {
+                  const std::vector<templates::Domain<int>>& subarray = {},
+                  tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
     templates::Fragment1D<int, int> fragment0;
     templates::Fragment1D<int, int> fragment1;
 
@@ -1378,16 +1422,19 @@ TEST_CASE_METHOD(
     f1atts.resize(fragment1.dim_.size());
     std::iota(f1atts.begin(), f1atts.end(), int(f0atts.size()));
 
-    struct FxRun1D instance;
+    FxRun1D instance;
     instance.fragments.push_back(fragment0);
     instance.fragments.push_back(fragment1);
     instance.num_user_cells = num_user_cells;
     instance.subarray = subarray;
+    if (condition) {
+      instance.condition.emplace(std::move(condition));
+    }
     instance.memory.total_budget_ = "20000";
     instance.memory.ratio_array_data_ = "0.5";
     instance.array.allow_dups_ = true;
 
-    run<Asserter, FxRun1D>(instance);
+    run<Asserter>(instance);
   };
 
   SECTION("Example") {
@@ -1400,8 +1447,11 @@ TEST_CASE_METHOD(
       const size_t num_user_cells = *rc::gen::inRange(1, 1024);
       const auto subarray =
           *rc::make_subarray_1d(templates::Domain<int>(1, 200));
+      auto condition =
+          *rc::make_query_condition<FxRun1D<>::FragmentType>(std::make_tuple(
+              templates::Domain<int>(1, 200), templates::Domain<int>(1, 200)));
       doit.operator()<tiledb::test::AsserterRapidcheck>(
-          fragment_size, num_user_cells, subarray);
+          fragment_size, num_user_cells, subarray, std::move(condition));
     });
   }
 }
@@ -1444,7 +1494,8 @@ TEST_CASE_METHOD(
                   size_t num_user_cells,
                   bool allow_dups,
                   const std::vector<templates::Domain<int>>& subarray =
-                      std::vector<templates::Domain<int>>()) {
+                      std::vector<templates::Domain<int>>(),
+                  tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
     const uint64_t total_budget = 100000;
     const double ratio_coords = 0.2;
 
@@ -1453,6 +1504,9 @@ TEST_CASE_METHOD(
     instance.array.dimension_.extent = int(num_fragments) * 2;
     instance.array.allow_dups_ = allow_dups;
     instance.subarray = subarray;
+    if (condition) {
+      instance.condition.emplace(std::move(condition));
+    }
 
     instance.memory.total_budget_ = std::to_string(total_budget);
     instance.memory.ratio_coords_ = std::to_string(ratio_coords);
@@ -1478,7 +1532,7 @@ TEST_CASE_METHOD(
 
     instance.num_user_cells = num_user_cells;
 
-    run<Asserter, FxRun1D>(instance);
+    run<Asserter>(instance);
   };
 
   SECTION("Example") {
@@ -1504,8 +1558,18 @@ TEST_CASE_METHOD(
       const bool allow_dups = *rc::gen::arbitrary<bool>();
       const auto subarray =
           *rc::make_subarray_1d(templates::Domain<int>(1, 200));
+      auto condition =
+          *rc::make_query_condition<FxRun1D<>::FragmentType>(std::make_tuple(
+              templates::Domain<int>(1, 200),
+              templates::Domain<int>(
+                  0, static_cast<int>(num_fragments * fragment_size))));
       doit.operator()<tiledb::test::AsserterRapidcheck>(
-          num_fragments, fragment_size, num_user_cells, allow_dups, subarray);
+          num_fragments,
+          fragment_size,
+          num_user_cells,
+          allow_dups,
+          subarray,
+          std::move(condition));
     });
   }
 }
@@ -1536,7 +1600,8 @@ TEST_CASE_METHOD(
                   size_t num_user_cells,
                   size_t tile_capacity,
                   bool allow_dups,
-                  const Subarray1DType<int>& subarray = {}) {
+                  const Subarray1DType<int>& subarray = {},
+                  tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
     FxRun1D instance;
     instance.num_user_cells = num_user_cells;
     instance.subarray = subarray;
@@ -1547,6 +1612,9 @@ TEST_CASE_METHOD(
     instance.array.dimension_.domain.lower_bound = 0;
     instance.array.dimension_.domain.upper_bound =
         static_cast<int>(num_fragments * fragment_size);
+    if (condition) {
+      instance.condition.emplace(std::move(condition));
+    }
 
     for (size_t f = 0; f < num_fragments; f++) {
       templates::Fragment1D<int, int> fragment;
@@ -1565,7 +1633,7 @@ TEST_CASE_METHOD(
 
     instance.num_user_cells = num_user_cells;
 
-    run<Asserter, FxRun1D>(instance);
+    run<Asserter>(instance);
   };
 
   SECTION("Example") {
@@ -1581,13 +1649,19 @@ TEST_CASE_METHOD(
       const bool allow_dups = *rc::gen::arbitrary<bool>();
       const auto subarray = *rc::make_subarray_1d(templates::Domain<int>(
           0, static_cast<int>(num_fragments * fragment_size)));
+      auto condition =
+          *rc::make_query_condition<FxRun1D<>::FragmentType>(std::make_tuple(
+              templates::Domain<int>(1, 200),
+              templates::Domain<int>(
+                  0, static_cast<int>(num_fragments * fragment_size))));
       doit.operator()<tiledb::test::AsserterRapidcheck>(
           num_fragments,
           fragment_size,
           num_user_cells,
           tile_capacity,
           allow_dups,
-          subarray);
+          subarray,
+          std::move(condition));
     });
   }
 }
@@ -1646,7 +1720,8 @@ TEST_CASE_METHOD(
                   size_t num_user_cells,
                   size_t tile_capacity,
                   bool allow_dups,
-                  const Subarray2DType<int, int>& subarray = {}) {
+                  const Subarray2DType<int, int>& subarray = {},
+                  tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
     FxRun2D instance;
     instance.num_user_cells = num_user_cells;
     instance.capacity = tile_capacity;
@@ -1654,6 +1729,9 @@ TEST_CASE_METHOD(
     instance.tile_order_ = tile_order;
     instance.cell_order_ = cell_order;
     instance.subarray = subarray;
+    if (condition) {
+      instance.condition.emplace(std::move(condition));
+    }
 
     auto row = [&](size_t f, size_t i) -> int {
       return 1 +
@@ -1743,6 +1821,12 @@ TEST_CASE_METHOD(
       const size_t tile_capacity = *rc::gen::inRange(4, 32);
       const auto subarray = *rc::make_subarray_2d(
           templates::Domain<int>(1, 200), templates::Domain<int>(1, 200));
+      auto condition =
+          *rc::make_query_condition<FxRun2D::FragmentType>(std::make_tuple(
+              templates::Domain<int>(1, 200),
+              templates::Domain<int>(1, 200),
+              templates::Domain<int>(
+                  0, static_cast<int>((num_fragments + 1) * fragment_size))));
 
       doit.operator()<tiledb::test::AsserterRapidcheck>(
           tile_order,
@@ -1752,7 +1836,8 @@ TEST_CASE_METHOD(
           num_user_cells,
           tile_capacity,
           allow_dups,
-          subarray);
+          subarray,
+          std::move(condition));
     });
   }
 }
@@ -1789,6 +1874,8 @@ TEST_CASE_METHOD(
     CSparseGlobalOrderFx,
     "Sparse global order reader: fragment skew 2d merge bound",
     "[sparse-global-order][rest][rapidcheck]") {
+  constexpr size_t d1_extent = 4;
+  constexpr size_t d2_extent = 4;
   auto doit = [this]<typename Asserter>(
                   tiledb_layout_t tile_order,
                   tiledb_layout_t cell_order,
@@ -1797,16 +1884,20 @@ TEST_CASE_METHOD(
                   size_t num_fragments,
                   size_t tile_capacity,
                   bool allow_dups,
-                  const Subarray2DType<int, int>& subarray = {}) {
+                  const Subarray2DType<int, int>& subarray = {},
+                  tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
     FxRun2D instance;
     instance.tile_order_ = tile_order;
     instance.cell_order_ = cell_order;
-    instance.d1.extent = 4;
-    instance.d2.extent = 4;
+    instance.d1.extent = d1_extent;
+    instance.d2.extent = d2_extent;
     instance.capacity = tile_capacity;
     instance.allow_dups = allow_dups;
     instance.num_user_cells = num_user_cells;
     instance.subarray = subarray;
+    if (condition) {
+      instance.condition.emplace(std::move(condition));
+    }
 
     const size_t tile_size_estimate = (1600 + instance.capacity * sizeof(int));
     const double coords_ratio =
@@ -1862,7 +1953,7 @@ TEST_CASE_METHOD(
       instance.fragments.push_back(fpoint);
     }
 
-    run<Asserter, FxRun2D>(instance);
+    run<Asserter>(instance);
   };
 
   SECTION("Example") {
@@ -1883,7 +1974,7 @@ TEST_CASE_METHOD(
   }
 
   SECTION("Rapidcheck") {
-    rc::prop("rapidcheck fragment skew", [doit]() {
+    rc::prop("rapidcheck fragment skew 2d merge bound", [doit]() {
       const auto tile_order =
           *rc::gen::element(TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR);
       const auto cell_order =
@@ -1895,6 +1986,14 @@ TEST_CASE_METHOD(
       const bool allow_dups = *rc::gen::arbitrary<bool>();
       const auto subarray = *rc::make_subarray_2d(
           templates::Domain<int>(1, 200), templates::Domain<int>(1, 200));
+      auto condition =
+          *rc::make_query_condition<FxRun2D::FragmentType>(std::make_tuple(
+              templates::Domain<int>(1, 200),
+              templates::Domain<int>(1, 200),
+              templates::Domain<int>(
+                  0,
+                  static_cast<int>(
+                      2 * num_fragments * d1_extent * d2_extent))));
       doit.operator()<tiledb::test::AsserterRapidcheck>(
           tile_order,
           cell_order,
@@ -1903,7 +2002,117 @@ TEST_CASE_METHOD(
           num_fragments,
           tile_capacity,
           allow_dups,
-          subarray);
+          subarray,
+          std::move(condition));
+    });
+  }
+}
+
+/**
+ * Test usage patterns where each fragment is kind of an entire data set,
+ * e.g. one fragment for observations from Monday, one for observations
+ * from Tuesday, one for observations from Wednesday, etc.
+ *
+ * This sort of usage is not really what fragments and time travel were
+ * originally built to support, but it is more flexible with respect
+ * to schema evolution than having time as another dimension would be,
+ * and as such at least one prominent customer is known to do this.
+ *
+ * What this looks like is each fragment covering essentially the entire
+ * domain of the array.  Queries which open the array at a specific
+ * timestamp are nice and easy; queries which do not open with a specific
+ * timestamp are sad because they do tons of work to de-duplicate.
+ */
+TEST_CASE_METHOD(
+    CSparseGlobalOrderFx,
+    "Sparse global order reader: fragment full copy 1d",
+    "[sparse-global-order][rest][rapidcheck]") {
+  using FxRunType = FxRun1D<Datatype::INT64, Datatype::INT64, Datatype::UINT16>;
+  auto doit = [this]<typename Asserter>(
+                  size_t num_fragments,
+                  templates::Dimension<Datatype::INT64> dimension,
+                  const Subarray1DType<int64_t>& subarray = {},
+                  tdb_unique_ptr<tiledb::sm::ASTNode> condition = nullptr) {
+    const size_t fragment_size =
+        std::min<size_t>(1024 * 32, dimension.domain.num_cells());
+
+    FxRunType instance;
+    instance.num_user_cells = 1024 * 1024;
+    instance.array.dimension_ = dimension;
+    instance.memory.total_budget_ = std::to_string(1024 * 1024 * 4);
+    instance.array.capacity_ = std::min<uint64_t>(
+        1024, std::max<uint64_t>(16, dimension.domain.num_cells() / 1024));
+    instance.array.allow_dups_ = false;
+    instance.subarray = subarray;
+    if (condition) {
+      instance.condition.emplace(std::move(condition));
+    }
+
+    for (size_t f = 0; f < num_fragments; f++) {
+      FxRunType::FragmentType fragment;
+
+      fragment.dim_.resize(fragment_size);
+      std::iota(
+          fragment.dim_.begin(),
+          fragment.dim_.end(),
+          dimension.domain.lower_bound);
+
+      std::get<0>(fragment.atts_).resize(fragment.dim_.size());
+      std::iota(
+          std::get<0>(fragment.atts_).begin(),
+          std::get<0>(fragment.atts_).end(),
+          0);
+
+      std::get<1>(fragment.atts_).resize(fragment.dim_.size());
+      std::iota(
+          std::get<1>(fragment.atts_).begin(),
+          std::get<1>(fragment.atts_).end(),
+          static_cast<uint16_t>(f * fragment.dim_.size()));
+
+      instance.fragments.push_back(fragment);
+    }
+
+    run<Asserter>(instance);
+  };
+
+  SECTION("Example") {
+    templates::Domain<int64_t> domain(0, 262143);
+    doit.operator()<AsserterCatch>(
+        8, templates::Dimension<Datatype::INT64>(domain, 1024));
+  }
+
+  SECTION("Condition") {
+    int64_t value = 524288;
+    tdb_unique_ptr<tiledb::sm::ASTNode> qc(new tiledb::sm::ASTNodeVal(
+        "a1", &value, sizeof(value), tiledb::sm::QueryConditionOp::GE));
+    templates::Domain<int64_t> domain(0, 262143);
+    doit.operator()<AsserterCatch>(
+        8,
+        templates::Dimension<Datatype::INT64>(domain, 1024),
+        {},
+        std::move(qc));
+  }
+
+  SECTION("Rapidcheck") {
+    rc::prop("rapidcheck fragment full copy 1d", [doit]() {
+      const size_t num_fragments = *rc::gen::inRange(2, 16);
+      const auto dimension =
+          *rc::gen::arbitrary<templates::Dimension<FxRunType::DimensionType>>();
+      const auto subarray = *rc::make_subarray_1d(dimension.domain);
+
+      const auto domains = std::make_tuple(
+          dimension.domain,
+          templates::Domain<int64_t>(0, dimension.domain.upper_bound),
+          templates::Domain<uint16_t>(
+              0,
+              static_cast<uint16_t>(std::min<int64_t>(
+                  std::numeric_limits<uint16_t>::max(),
+                  dimension.domain.upper_bound * num_fragments))));
+      auto condition =
+          *rc::make_query_condition<FxRunType::FragmentType>(domains);
+
+      doit.operator()<AsserterRapidcheck>(
+          num_fragments, dimension, subarray, std::move(condition));
     });
   }
 }
@@ -2797,9 +3006,9 @@ void CSparseGlobalOrderFx::create_array(const Instance& instance) {
     attribute_cell_val_nums.push_back(1);
     attribute_compressors.push_back(std::make_pair(TILEDB_FILTER_NONE, -1));
   };
-  std::apply(
-      [&]<typename... As>(As... attribute) { (add_attribute(attribute), ...); },
-      attributes);
+  for (const Datatype atype : attributes) {
+    add_attribute(atype);
+  }
 
   tiledb::test::create_array(
       context(),
@@ -2866,15 +3075,26 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) {
     auto expect_dimensions = expect.dimensions();
     auto expect_attributes = expect.attributes();
 
-    if (instance.subarray.empty()) {
+    if (instance.subarray.empty() && !instance.condition.has_value()) {
       stdx::extend(expect_dimensions, fragment.dimensions());
       stdx::extend(expect_attributes, fragment.attributes());
     } else {
       std::vector<uint64_t> accept;
+      std::optional<
+          templates::QueryConditionEvalSchema<typename Instance::FragmentType>>
+          eval;
+      if (instance.condition.has_value()) {
+        eval.emplace();
+      }
       for (uint64_t i = 0; i < fragment.size(); i++) {
-        if (instance.accept(fragment, i)) {
-          accept.push_back(i);
+        if (!instance.pass_subarray(fragment, i)) {
+          continue;
+        }
+        if (eval.has_value() &&
+            !eval->test(fragment, i, *instance.condition.value().get())) {
+          continue;
         }
+        accept.push_back(i);
       }
       const auto fdimensions =
           stdx::select(fragment.dimensions(), std::span(accept));
@@ -2941,6 +3161,13 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) {
     tiledb_subarray_free(&subarray);
   }
 
+  if (instance.condition.has_value()) {
+    tiledb::sm::QueryCondition qc(instance.condition->get()->clone());
+    const auto rc =
+        query->query_->set_condition(qc);  // SAFETY: this performs a deep copy
+    ASSERTER(rc.to_string() == "Ok");
+  }
+
   // Prepare output buffer
   std::decay_t<decltype(instance.fragments[0])> out;
 
@@ -3126,31 +3353,31 @@ namespace rc {
 /**
  * @return a generator of valid subarrays within `domain`
  */
-Gen<std::vector<templates::Domain<int>>> make_subarray_1d(
-    const templates::Domain<int>& domain) {
+template <DimensionType D>
+Gen<std::vector<templates::Domain<D>>> make_subarray_1d(
+    const templates::Domain<D>& domain) {
   // NB: when (if) multi-range subarray is supported for global order
   // (or if this is used for non-global order)
   // change `num_ranges` to use the weighted element version
-  std::optional<Gen<int>> num_ranges;
+  std::optional<Gen<D>> num_ranges;
   if (true) {
-    num_ranges = gen::just<int>(1);
+    num_ranges = gen::just<D>(1);
   } else {
-    num_ranges = gen::weightedElement<int>(
+    num_ranges = gen::weightedElement<D>(
         {{50, 1}, {25, 2}, {13, 3}, {7, 4}, {4, 5}, {1, 6}});
   }
 
   return gen::mapcat(*num_ranges, [domain](int num_ranges) {
-    return gen::container<std::vector<templates::Domain<int>>>(
-        num_ranges, rc::make_range<int>(domain));
+    return gen::container<std::vector<templates::Domain<D>>>(
+        num_ranges, rc::make_range<D>(domain));
   });
 }
 
-template <>
-struct Arbitrary<FxRun1D> {
-  static Gen<FxRun1D> arbitrary() {
-    constexpr Datatype DIMENSION_TYPE = Datatype::INT32;
-    using CoordType = tiledb::type::datatype_traits<DIMENSION_TYPE>::value_type;
+template <Datatype DIMENSION_TYPE, Datatype... ATTR_TYPES>
+struct Arbitrary<FxRun1D<DIMENSION_TYPE, ATTR_TYPES...>> {
+  using value_type = FxRun1D<DIMENSION_TYPE, ATTR_TYPES...>;
 
+  static Gen<value_type> arbitrary() {
     auto dimension = gen::arbitrary<templates::Dimension<DIMENSION_TYPE>>();
     auto allow_dups = gen::arbitrary<bool>();
 
@@ -3174,33 +3401,39 @@ struct Arbitrary<FxRun1D> {
           templates::Dimension<DIMENSION_TYPE> dimension;
           std::tie(allow_dups, dimension) = arg;
 
-          auto fragment = rc::make_fragment_1d<CoordType, int>(
-              allow_dups, dimension.domain);
+          auto fragment = rc::make_fragment_1d<
+              typename value_type::CoordType,
+              typename tiledb::type::datatype_traits<
+                  ATTR_TYPES>::value_type...>(allow_dups, dimension.domain);
+
+          auto fragments = gen::nonEmpty(
+              gen::container<std::vector<typename value_type::FragmentType>>(
+                  fragment));
+
+          auto fragments_and_qc = gen::mapcat(fragments, [](auto fragments) {
+            auto condition =
+                make_query_condition<typename value_type::FragmentType>(
+                    field_domains(fragments));
+            return gen::pair(gen::just(fragments), condition);
+          });
 
           return gen::tuple(
               gen::just(allow_dups),
               gen::just(dimension),
               make_subarray_1d(dimension.domain),
-              gen::nonEmpty(
-                  gen::container<std::vector<templates::Fragment1D<int, int>>>(
-                      fragment)));
+              fragments_and_qc);
         });
 
     auto num_user_cells = gen::inRange(1, 8 * 1024 * 1024);
 
     return gen::apply(
-        [](std::tuple<
-               bool,
-               templates::Dimension<DIMENSION_TYPE>,
-               std::vector<templates::Domain<CoordType>>,
-               std::vector<templates::Fragment1D<int, int>>> fragments,
-           int num_user_cells) {
+        [](auto fragments, int num_user_cells) {
           FxRun1D instance;
-          std::tie(
-              instance.array.allow_dups_,
-              instance.array.dimension_,
-              instance.subarray,
-              instance.fragments) = fragments;
+          instance.array.allow_dups_ = std::get<0>(fragments);
+          instance.array.dimension_ = std::get<1>(fragments);
+          instance.subarray = std::get<2>(fragments);
+          instance.fragments = std::move(std::get<3>(fragments).first);
+          instance.condition = std::move(std::get<3>(fragments).second);
 
           instance.num_user_cells = num_user_cells;
 
@@ -3277,13 +3510,22 @@ struct Arbitrary<FxRun2D> {
 
       auto fragment = rc::make_fragment_2d<Coord0Type, Coord1Type, int>(
           allow_dups, d0.domain, d1.domain);
+
+      auto fragments = gen::nonEmpty(
+          gen::container<std::vector<FxRun2D::FragmentType>>(fragment));
+
+      auto fragments_and_qc = gen::mapcat(fragments, [](auto fragments) {
+        auto condition = make_query_condition<FxRun2D::FragmentType>(
+            field_domains(fragments));
+        return gen::pair(gen::just(fragments), condition);
+      });
+
       return gen::tuple(
           gen::just(allow_dups),
           gen::just(d0),
           gen::just(d1),
           make_subarray_2d(d0.domain, d1.domain),
-          gen::nonEmpty(
-              gen::container<std::vector<FxRun2D::FragmentType>>(fragment)));
+          fragments_and_qc);
     });
 
     auto num_user_cells = gen::inRange(1, 8 * 1024 * 1024);
@@ -3296,12 +3538,12 @@ struct Arbitrary<FxRun2D> {
            tiledb_layout_t tile_order,
            tiledb_layout_t cell_order) {
           FxRun2D instance;
-          std::tie(
-              instance.allow_dups,
-              instance.d1,
-              instance.d2,
-              instance.subarray,
-              instance.fragments) = fragments;
+          instance.allow_dups = std::get<0>(fragments);
+          instance.d1 = std::get<1>(fragments);
+          instance.d2 = std::get<2>(fragments);
+          instance.subarray = std::get<3>(fragments);
+          instance.fragments = std::move(std::get<4>(fragments).first);
+          instance.condition = std::move(std::get<4>(fragments).second);
 
           // TODO: capacity
           instance.num_user_cells = num_user_cells;
@@ -3317,55 +3559,6 @@ struct Arbitrary<FxRun2D> {
   }
 };
 
-/**
- * Specializes `show` to print the final test case after shrinking
- */
-template <>
-void show<FxRun1D>(const FxRun1D& instance, std::ostream& os) {
-  size_t f = 0;
-
-  os << "{" << std::endl;
-  os << "\t\"fragments\": [" << std::endl;
-  for (const auto& fragment : instance.fragments) {
-    os << "\t\t{" << std::endl;
-    os << "\t\t\t\"coords\": [" << std::endl;
-    os << "\t\t\t\t";
-    show(fragment.dim_, os);
-    os << std::endl;
-    os << "\t\t\t], " << std::endl;
-    os << "\t\t\t\"atts\": [" << std::endl;
-    os << "\t\t\t\t";
-    show(std::get<0>(fragment.atts_), os);
-    os << std::endl;
-    os << "\t\t\t] " << std::endl;
-    os << "\t\t}";
-    if ((f++) + 1 < instance.fragments.size()) {
-      os << ", " << std::endl;
-    } else {
-      os << std::endl;
-    }
-  }
-  os << "\t]," << std::endl;
-  os << "\t\"num_user_cells\": " << instance.num_user_cells << std::endl;
-  os << "\t\"array\": {" << std::endl;
-  os << "\t\t\"allow_dups\": " << instance.array.allow_dups_ << std::endl;
-  os << "\t\t\"domain\": [" << instance.array.dimension_.domain.lower_bound
-     << ", " << instance.array.dimension_.domain.upper_bound << "],"
-     << std::endl;
-  os << "\t\t\"extent\": " << instance.array.dimension_.extent << std::endl;
-  os << "\t}," << std::endl;
-  os << "\t\"memory\": {" << std::endl;
-  os << "\t\t\"total_budget\": " << instance.memory.total_budget_ << ", "
-     << std::endl;
-  os << "\t\t\"ratio_tile_ranges\": " << instance.memory.ratio_tile_ranges_
-     << ", " << std::endl;
-  os << "\t\t\"ratio_array_data\": " << instance.memory.ratio_array_data_
-     << ", " << std::endl;
-  os << "\t\t\"ratio_coords\": " << instance.memory.ratio_coords_ << std::endl;
-  os << "\t}" << std::endl;
-  os << "}";
-}
-
 /**
  * Specializes `show` to print the final test case after shrinking
  */
@@ -3446,8 +3639,10 @@ TEST_CASE_METHOD(
     "[sparse-global-order][rest][rapidcheck]") {
   SECTION("Rapidcheck") {
     rc::prop(
-        "rapidcheck arbitrary 1d", [this](rc::NonShrinking<FxRun1D> instance) {
-          run<tiledb::test::AsserterRapidcheck, FxRun1D>(instance);
+        "rapidcheck arbitrary 1d",
+        [this](rc::NonShrinking<FxRun1D<>> instance) {
+          run<tiledb::test::AsserterRapidcheck, decltype(instance)::value_type>(
+              instance);
         });
   }
 }
diff --git a/test/support/rapidcheck/array_templates.h b/test/support/rapidcheck/array_templates.h
index 95f8b671030..80d71fcbe1c 100644
--- a/test/support/rapidcheck/array_templates.h
+++ b/test/support/rapidcheck/array_templates.h
@@ -49,10 +49,10 @@ struct Arbitrary<templates::Domain<D>> {
     // NB: `gen::inRange` is exclusive at the upper end but tiledb domain is
     // inclusive. So we have to use `int64_t` to avoid overflow.
     auto bounds = gen::mapcat(gen::arbitrary<D>(), [](D lb) {
-      if (std::is_same<D, int64_t>::value) {
+      if constexpr (std::is_same<D, int64_t>::value) {
         return gen::pair(
             gen::just(lb), gen::inRange(lb, std::numeric_limits<D>::max()));
-      } else if (std::is_same<D, uint64_t>::value) {
+      } else if constexpr (std::is_same<D, uint64_t>::value) {
         return gen::pair(
             gen::just(lb), gen::inRange(lb, std::numeric_limits<D>::max()));
       } else {
@@ -128,7 +128,7 @@ struct Arbitrary<templates::Dimension<D>> {
         });
 
     return gen::map(tup, [](std::pair<Domain<CoordType>, CoordType> tup) {
-      return templates::Dimension<D>{.domain = tup.first, .extent = tup.second};
+      return templates::Dimension<D>(tup.first, tup.second);
     });
   }
 };
diff --git a/test/support/rapidcheck/query_condition.h b/test/support/rapidcheck/query_condition.h
new file mode 100644
index 00000000000..22b30aebc43
--- /dev/null
+++ b/test/support/rapidcheck/query_condition.h
@@ -0,0 +1,206 @@
+/**
+ * @file test/support/rapidcheck/query_condition.h
+ *
+ * @section LICENSE
+ *
+ * The MIT License
+ *
+ * @copyright Copyright (c) 2022-2024 TileDB, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ * This file defines rapidcheck generators for query condition AST.
+ */
+
+#ifndef TILEDB_RAPIDCHECK_QUERY_CONDITION_H
+#define TILEDB_RAPIDCHECK_QUERY_CONDITION_H
+
+#include "tiledb/sm/query/ast/query_ast.h"
+
+#include "test/support/rapidcheck/array_templates.h"
+
+#include <test/support/src/array_templates.h>
+#include <test/support/stdx/tuple.h>
+#include <test/support/tdb_rapidcheck.h>
+
+namespace tiledb::test::templates {
+
+// Helper function used for `domain_type_t`.
+// This is not intended to be evaluated.
+template <AttributeType... Ts>
+std::tuple<Domain<typename Ts::value_type>...> domain_type_f(
+    const std::tuple<Ts...>&);
+
+/**
+ * Maps a tuple type `(T1, T2, ...)` to a type
+ * `(Domain<T1>, Domain<T2>, ...)`.
+ */
+template <typename Tuple>
+using domain_type_t = decltype(domain_type_f(std::declval<Tuple>()));
+
+/**
+ * Maps a `FragmentType` to a tuple type which has a `Domain<T>`
+ * for each of the dimensions and attributes.
+ */
+template <FragmentType Fragment>
+struct query_condition_domain {
+  using field_tuple = decltype(std::tuple_cat(
+      std::declval<stdx::decay_tuple<
+          decltype(std::declval<const Fragment&>().dimensions())>>(),
+      std::declval<stdx::decay_tuple<
+          decltype(std::declval<const Fragment&>().attributes())>>()));
+
+  using value_type = domain_type_t<field_tuple>;
+};
+
+}  // namespace tiledb::test::templates
+
+namespace rc {
+
+using namespace tiledb::test;
+
+template <>
+struct Arbitrary<tiledb::sm::QueryConditionOp> {
+  static Gen<tiledb::sm::QueryConditionOp> arbitrary() {
+    // NOT IN and IN are not handled yet by the users of this
+    return gen::element(
+        tiledb::sm::QueryConditionOp::LT,
+        tiledb::sm::QueryConditionOp::LE,
+        tiledb::sm::QueryConditionOp::GT,
+        tiledb::sm::QueryConditionOp::GE,
+        tiledb::sm::QueryConditionOp::EQ,
+        tiledb::sm::QueryConditionOp::NE);
+  }
+};
+
+/**
+ * @return a generator which produces arbitrary query conditions over `Fragment`
+ * using ranges drawn from `field_domains`
+ */
+template <templates::FragmentType Fragment>
+Gen<tdb_unique_ptr<tiledb::sm::ASTNode>> make_query_condition(
+    const typename query_condition_domain<Fragment>::value_type&
+        field_domains) {
+  using DimensionTuple =
+      stdx::decay_tuple<decltype(std::declval<const Fragment>().dimensions())>;
+  using AttributeTuple =
+      stdx::decay_tuple<decltype(std::declval<const Fragment>().attributes())>;
+  using FieldTuple = decltype(std::tuple_cat(
+      std::declval<DimensionTuple>(), std::declval<AttributeTuple>()));
+
+  auto field = gen::inRange<size_t>(0, std::tuple_size_v<FieldTuple>);
+  auto op = gen::arbitrary<tiledb::sm::QueryConditionOp>();
+
+  auto parts = gen::mapcat(gen::pair(field, op), [field_domains](auto arg) {
+    size_t field;
+    tiledb::sm::QueryConditionOp op;
+    std::tie(field, op) = arg;
+
+    const auto field_names = QueryConditionEvalSchema<Fragment>().field_names_;
+
+    using R = std::pair<std::string, Gen<std::string>>;
+    auto make_value_gen = [&](auto i) -> std::optional<R> {
+      if (field == i) {
+        auto value = make_range(std::get<i>(field_domains));
+        auto p = std::make_pair(field_names[i], gen::map(value, [](auto value) {
+                                  return std::string(
+                                      reinterpret_cast<char*>(&value),
+                                      sizeof(value));
+                                }));
+        return std::optional<R>{p};
+      } else {
+        return std::optional<R>{};
+      }
+    };
+
+    auto fielddata = stdx::fold_optional<R>(
+        std::make_index_sequence<std::tuple_size_v<FieldTuple>>{},
+        make_value_gen);
+
+    return gen::tuple(
+        gen::just(fielddata.value().first),
+        gen::just(op),
+        fielddata.value().second);
+  });
+
+  return gen::map(parts, [](auto arg) {
+    return tdb_unique_ptr<tiledb::sm::ASTNode>(new tiledb::sm::ASTNodeVal(
+        std::get<0>(arg),
+        std::get<2>(arg).data(),
+        std::get<2>(arg).size(),
+        std::get<1>(arg)));
+  });
+}
+
+}  // namespace rc
+
+namespace tiledb::test::templates {
+
+/**
+ * @return a tuple containing the min/max values of each field in `fragment`.
+ */
+template <FragmentType Fragment>
+typename query_condition_domain<Fragment>::value_type field_domains(
+    const Fragment& fragment) {
+  auto make_domain = []<AttributeType T>(const std::vector<T>& field) {
+    return Domain<T>(
+        *std::min_element(field.begin(), field.end()),
+        *std::max_element(field.begin(), field.end()));
+  };
+
+  return std::apply(
+      [make_domain]<AttributeType... Ts>(const std::vector<Ts>&... fields) {
+        return std::make_tuple(make_domain(fields)...);
+      },
+      std::tuple_cat(fragment.dimensions(), fragment.attributes()));
+}
+
+/**
+ * @return a tuple containing the min/max values of each field in `fragments`.
+ */
+template <FragmentType Fragment>
+typename query_condition_domain<Fragment>::value_type field_domains(
+    const std::vector<Fragment>& fragments) {
+  auto make_union_domain = [](auto& d1, const auto d2) {
+    d1 = Domain(
+        std::min(d1.lower_bound, d2.lower_bound),
+        std::max(d1.upper_bound, d2.upper_bound));
+  };
+
+  auto full_domain = field_domains<Fragment>(fragments[0]);
+  for (size_t i = 1; i < fragments.size(); i++) {
+    const auto this_domain = field_domains<Fragment>(fragments[i]);
+    std::apply(
+        [&](auto... full_field) {
+          std::apply(
+              [&](const auto... this_field) {
+                (make_union_domain(full_field, this_field), ...);
+              },
+              this_domain);
+        },
+        full_domain);
+  }
+  return full_domain;
+}
+
+}  // namespace tiledb::test::templates
+
+#endif
diff --git a/test/support/src/array_templates.h b/test/support/src/array_templates.h
index d70d2217b20..5cc648fc9ae 100644
--- a/test/support/src/array_templates.h
+++ b/test/support/src/array_templates.h
@@ -35,11 +35,15 @@
 #define TILEDB_ARRAY_TEMPLATES_H
 
 #include "tiledb.h"
+#include "tiledb/common/unreachable.h"
+#include "tiledb/sm/query/ast/query_ast.h"
 #include "tiledb/type/datatype_traits.h"
 #include "tiledb/type/range/range.h"
 
 #include <test/support/assert_helpers.h>
 #include <test/support/src/error_helpers.h>
+#include <test/support/stdx/fold.h>
+#include <test/support/stdx/tuple.h>
 
 #include <algorithm>
 #include <concepts>
@@ -180,15 +184,113 @@ template <tiledb::sm::Datatype DATATYPE>
 struct Dimension {
   using value_type = tiledb::type::datatype_traits<DATATYPE>::value_type;
 
+  Dimension() = default;
+  Dimension(Domain<value_type> domain, value_type extent)
+      : domain(domain)
+      , extent(extent) {
+  }
+
   Domain<value_type> domain;
   value_type extent;
 };
 
+/**
+ * Schema of named fields for simple evaluation of a query condition
+ */
+template <FragmentType Fragment>
+struct QueryConditionEvalSchema {
+  std::vector<std::string> field_names_;
+
+  QueryConditionEvalSchema() {
+    stdx::decay_tuple<decltype(std::declval<Fragment>().dimensions())> dims;
+    stdx::decay_tuple<decltype(std::declval<Fragment>().attributes())> atts;
+
+    auto add_dimension = [&](auto) {
+      field_names_.push_back("d" + std::to_string(field_names_.size() + 1));
+    };
+    auto add_attribute = [&](auto) {
+      field_names_.push_back(
+          "a" +
+          std::to_string(
+              field_names_.size() + 1 - std::tuple_size<decltype(dims)>()));
+    };
+
+    std::apply([&](const auto... dim) { (add_dimension(dim), ...); }, dims);
+    std::apply([&](const auto... att) { (add_attribute(att), ...); }, atts);
+  }
+
+  /**
+   * @return true if a value passes a simple condition
+   */
+  template <AttributeType T>
+  static bool test(const T& value, const tiledb::sm::ASTNode& condition) {
+    switch (condition.get_op()) {
+      case tiledb::sm::QueryConditionOp::LT:
+        return value < *static_cast<const T*>(condition.get_value_ptr());
+      case tiledb::sm::QueryConditionOp::LE:
+        return value <= *static_cast<const T*>(condition.get_value_ptr());
+      case tiledb::sm::QueryConditionOp::GT:
+        return value > *static_cast<const T*>(condition.get_value_ptr());
+      case tiledb::sm::QueryConditionOp::GE:
+        return value >= *static_cast<const T*>(condition.get_value_ptr());
+      case tiledb::sm::QueryConditionOp::EQ:
+        return value == *static_cast<const T*>(condition.get_value_ptr());
+      case tiledb::sm::QueryConditionOp::NE:
+        return value != *static_cast<const T*>(condition.get_value_ptr());
+      case tiledb::sm::QueryConditionOp::IN:
+      case tiledb::sm::QueryConditionOp::NOT_IN:
+      case tiledb::sm::QueryConditionOp::ALWAYS_TRUE:
+      case tiledb::sm::QueryConditionOp::ALWAYS_FALSE:
+      default:
+        // not implemented here, lazy
+        stdx::unreachable();
+    }
+  }
+
+  /**
+   * @return true if `record` passes a simple (i.e. non-combination) query
+   * condition
+   */
+  bool test(
+      const Fragment& fragment,
+      int record,
+      const tiledb::sm::ASTNode& condition) const {
+    using DimensionTuple = stdx::decay_tuple<decltype(fragment.dimensions())>;
+    using AttributeTuple = stdx::decay_tuple<decltype(fragment.attributes())>;
+
+    const auto dim_eval = stdx::fold_sequence(
+        std::make_index_sequence<std::tuple_size_v<DimensionTuple>>{},
+        [&](auto i) {
+          if (condition.get_field_name() == field_names_[i]) {
+            return test(std::get<i>(fragment.dimensions())[record], condition);
+          } else {
+            return false;
+          }
+        });
+    if (dim_eval) {
+      return dim_eval;
+    }
+
+    return stdx::fold_sequence(
+        std::make_index_sequence<std::tuple_size_v<AttributeTuple>>{},
+        [&](auto i) {
+          if (condition.get_field_name() ==
+              field_names_[i + std::tuple_size_v<DimensionTuple>]) {
+            return test(std::get<i>(fragment.attributes())[record], condition);
+          } else {
+            return false;
+          }
+        });
+  }
+};
+
 /**
  * Data for a one-dimensional array
  */
 template <DimensionType D, AttributeType... Att>
 struct Fragment1D {
+  using DimensionType = D;
+
   std::vector<D> dim_;
   std::tuple<std::vector<Att>...> atts_;
 
diff --git a/test/support/stdx/fold.h b/test/support/stdx/fold.h
new file mode 100644
index 00000000000..f5e149c544d
--- /dev/null
+++ b/test/support/stdx/fold.h
@@ -0,0 +1,73 @@
+/**
+ * @file test/support/stdx/fold.h
+ *
+ * @section LICENSE
+ *
+ * The MIT License
+ *
+ * @copyright Copyright (c) 2025 TileDB, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @section DESCRIPTION
+ *
+ * This file defines functions which do things you would want a fold expression
+ * to do but can't figure out how to make them do it.
+ */
+
+#ifndef TILEDB_TEST_SUPPORT_FOLD_H
+#define TILEDB_TEST_SUPPORT_FOLD_H
+
+namespace stdx {
+
+template <typename T, T... S, typename F>
+constexpr bool fold_sequence(std::integer_sequence<T, S...>, F&& f) {
+  return (f(std::integral_constant<T, S>{}) || ...);
+}
+
+template <typename T, T First, T... Rest>
+struct fold_optional_t {
+  template <typename R, typename F>
+  static constexpr std::optional<R> fold(F&& f) {
+    const auto maybe = f(std::integral_constant<T, First>{});
+    if (maybe.has_value()) {
+      return maybe;
+    } else {
+      return fold_optional_t<T, Rest...>::template fold<R, F>(f);
+    }
+  }
+};
+
+template <typename T, T Only>
+struct fold_optional_t<T, Only> {
+  template <typename R, typename F>
+  static constexpr std::optional<R> fold(F&& f) {
+    return f(std::integral_constant<T, Only>{});
+  }
+};
+
+template <typename R, typename T, T... S, typename F>
+constexpr std::optional<R> fold_optional(
+    std::integer_sequence<T, S...>, F&& f) {
+  return fold_optional_t<T, S...>::template fold<R, F>(f);
+}
+
+}  // namespace stdx
+
+#endif
diff --git a/test/support/stdx/tuple.h b/test/support/stdx/tuple.h
index 953c041b258..f3bf79666ea 100644
--- a/test/support/stdx/tuple.h
+++ b/test/support/stdx/tuple.h
@@ -76,6 +76,19 @@ std::tuple<const std::decay_t<Ts>&...> reference_tuple(
       tuple);
 }
 
+// Helper function used for `value_type_tuple_t`.
+// This is not intended to be evaluated.
+template <typename... Ts>
+constexpr std::tuple<typename Ts::value_type...> value_type_tuple_f(
+    std::tuple<Ts...> tuple);
+
+/**
+ * Maps a tuple type `(T1, T2, ...)`,
+ * to a type `(T1::value_type, T2::value_type, ...)`.
+ */
+template <typename Tuple>
+using value_type_tuple_t = decltype(value_type_tuple_f(std::declval<Tuple>()));
+
 /**
  * Given two tuples of vectors, extends each of the fields of `dst`
  * with the corresponding field of `src`.
@@ -131,4 +144,5 @@ std::tuple<std::vector<Ts>...> select(
 }
 
 }  // namespace stdx
+
 #endif
diff --git a/test/support/tdb_rapidcheck.h b/test/support/tdb_rapidcheck.h
index 2f7907de580..7b2c0893859 100644
--- a/test/support/tdb_rapidcheck.h
+++ b/test/support/tdb_rapidcheck.h
@@ -79,8 +79,10 @@ namespace rc {
  */
 template <typename T>
 struct NonShrinking {
+  using value_type = T;
+
   NonShrinking(T&& inner)
-      : inner_(inner) {
+      : inner_(std::move(inner)) {
   }
 
   T inner_;
diff --git a/tiledb/sm/query/readers/result_coords.h b/tiledb/sm/query/readers/result_coords.h
index 79eacf6c133..1572cc133c8 100644
--- a/tiledb/sm/query/readers/result_coords.h
+++ b/tiledb/sm/query/readers/result_coords.h
@@ -227,7 +227,8 @@ struct GlobalOrderResultCoords
    *
    * @return Max slab length that can be merged for this tile.
    */
-  uint64_t max_slab_length() {
+  uint64_t max_slab_length(
+      uint64_t upper_bound = std::numeric_limits<uint64_t>::max()) const {
     uint64_t ret = 1;
     uint64_t cell_num = base::tile_->cell_num();
     uint64_t next_pos = base::pos_ + 1;
@@ -250,13 +251,14 @@ struct GlobalOrderResultCoords
 
       // With bitmap, find the longest contiguous set of bits in the bitmap
       // from the current position.
-      while (next_pos < cell_num && bitmap[next_pos] == 1) {
+      while (ret < upper_bound && next_pos < cell_num &&
+             bitmap[next_pos] == 1) {
         next_pos++;
         ret++;
       }
     } else {
       // No bitmap, add all cells from current position.
-      ret = cell_num - base::pos_;
+      ret = std::min(upper_bound, cell_num - base::pos_);
     }
 
     return ret;
@@ -273,15 +275,38 @@ struct GlobalOrderResultCoords
    * @param cmp The comparator class. Calling cmp(current, next) should tell us
    * if current is bigger or equal than next in the order of the comparator.
    *
+   * @postcondition this method has no side-effects if it is never called
+   * concurrently by multiple threads. If multiple threads call this method
+   * concurrently then results may be undefined.
+   *
    * @return Max slab length that can be merged for this tile.
    */
   template <GlobalCellComparable GlobalOrderLowerBound, class CompType>
   uint64_t max_slab_length(
-      const GlobalOrderLowerBound& next, const CompType& cmp) {
+      const GlobalOrderLowerBound& next, const CompType& cmp) const {
     uint64_t cell_num = base::tile_->cell_num();
 
-    // Store the original position.
-    uint64_t original_pos = base::pos_;
+    // The method is declared `const` to signal to the caller that it has
+    // no side effects. Internally we will modify `base::pos_` because
+    // the comparators need that to get the right coordinate.
+    // This is only a problem if this is called concurrently (and even then
+    // it would have been a problem anyway).
+    uint64_t* basepos = const_cast<uint64_t*>(&this->pos_);
+
+    // Store the original position and use RAII to ensure we restore it.
+    struct BasePosGuard {
+      uint64_t* basepos;
+      uint64_t original_pos;
+
+      BasePosGuard(uint64_t* basepos)
+          : basepos(basepos)
+          , original_pos(*basepos) {
+      }
+      ~BasePosGuard() {
+        *basepos = original_pos;
+      }
+    };
+    BasePosGuard savepos(basepos);
 
     // Max posssible position in the tile. Defaults to the last cell in the
     // tile, it might get updated if we have a bitmap below.
@@ -295,7 +320,7 @@ struct GlobalOrderResultCoords
     if (base::tile_->has_post_dedup_bmp()) {
       auto& bitmap = base::tile_->post_dedup_bitmap();
       // Current cell is not in the bitmap.
-      if (!bitmap[base::pos_]) {
+      if (!bitmap[*basepos]) {
         return 0;
       }
 
@@ -303,13 +328,13 @@ struct GlobalOrderResultCoords
       // return 1.
       const bool overlapping_ranges = std::is_same<BitmapType, uint64_t>::value;
       if constexpr (overlapping_ranges) {
-        if (bitmap[base::pos_] != 1) {
+        if (bitmap[*basepos] != 1) {
           return 1;
         }
       }
 
       // Compute max position.
-      max_pos = base::pos_;
+      max_pos = *basepos;
       while (max_pos < cell_num && bitmap[max_pos] == 1) {
         max_pos++;
       }
@@ -327,14 +352,13 @@ struct GlobalOrderResultCoords
     // ones. It will never take more comparisons that a linear search.
     uint64_t power_of_two = 1;
     bool return_max = true;
-    while (return_max && base::pos_ != max_pos) {
-      base::pos_ = std::min(original_pos + power_of_two, max_pos);
+    while (return_max && *basepos != max_pos) {
+      *basepos = std::min(savepos.original_pos + power_of_two, max_pos);
       if (cmp(*this, next)) {
         return_max = false;
 
         // If we exit on first comprarison, return 1.
         if (power_of_two == 1) {
-          base::pos_ = original_pos;
           return 1;
         }
       } else {
@@ -346,28 +370,26 @@ struct GlobalOrderResultCoords
     // cell until max_pos is smaller than next. So return the maximum cell
     // slab.
     if (return_max) {
-      base::pos_ = original_pos;
-      return max_pos - original_pos + 1;
+      return max_pos - savepos.original_pos + 1;
     }
 
     // We have an upper bound and a lower bound for our search with our power
     // of twos found above. Run a bisection search in between to find the exact
     // cell.
     uint64_t left = power_of_two / 2;
-    uint64_t right = base::pos_;
+    uint64_t right = *basepos;
     while (left != right - 1) {
       // Check against mid.
-      base::pos_ = left + (right - left) / 2;
+      *basepos = left + (right - left) / 2;
       if (!cmp(*this, next)) {
-        left = base::pos_;
+        left = *basepos;
       } else {
-        right = base::pos_;
+        right = *basepos;
       }
     }
 
     // Restore the original position and return.
-    base::pos_ = original_pos;
-    return left - original_pos + 1;
+    return left - savepos.original_pos + 1;
   }
 
  private:
diff --git a/tiledb/sm/query/readers/sparse_global_order_reader.cc b/tiledb/sm/query/readers/sparse_global_order_reader.cc
index 4236ae60813..be306131e0a 100644
--- a/tiledb/sm/query/readers/sparse_global_order_reader.cc
+++ b/tiledb/sm/query/readers/sparse_global_order_reader.cc
@@ -1855,9 +1855,12 @@ SparseGlobalOrderReader<BitmapType>::merge_result_cell_slabs(
           }
         } else {
           if (add_next_cell_result == AddNextCellResult::NeedMoreTiles) {
-            // e.g. because we were hitting duplicate coords and reached
-            // the end of a tile while de-duplicating
-            length = 1;
+            // This happens while de-duplicating, so this `NeedMoreTiles`
+            // came from a different fragment. Emit this coordinate
+            // (if it qualifies) but not anything past it, since they might
+            // need to be de-duplicated with coordinates from the next round
+            // of tiles.
+            length = to_process.max_slab_length(1);
           } else if (tile_queue.empty()) {
             length = to_process.max_slab_length();
           } else {