Method compute_range_uint64

tiledb/sm/subarray/subarray_partitioner.cc:1345–1401

}

void SubarrayPartitioner::compute_range_uint64(
    const Subarray& range,
    std::vector<std::array<uint64_t, 2>>* range_uint64,
    bool* unsplittable) const {
  // Initializations
  const auto& array_schema = subarray_.array()->array_schema_latest();
  auto dim_num = array_schema.dim_num();
  const Range* r;
  *unsplittable = true;
  range_uint64->resize(dim_num);
  Hilbert h(dim_num);
  auto bits = h.bits();
  auto max_bucket_val = ((uint64_t)1 << bits) - 1;

  // Default values for empty range start/end
  auto max_string = std::string("\x7F\x7F\x7F\x7F\x7F\x7F\x7F\x7F", 8);

  // Calculate mapped range
  bool empty_start, empty_end;
  for (uint32_t d = 0; d < dim_num; ++d) {
    auto dim{array_schema.dimension_ptr(d)};
    auto var = dim->var_size();
    range.get_range(d, 0, &r);
    empty_start = var ? (r->start_size() == 0) : r->empty();
    empty_end = var ? (r->end_size() == 0) : r->empty();
    auto max_default =
        var ? dim->map_to_uint64(
                  max_string.data(), max_string.size(), bits, max_bucket_val) :
              (UINT64_MAX >> (64 - bits));
    if (r->var_size()) {
      auto start_str = r->start_str();
      (*range_uint64)[d][0] =
          empty_start ? 0 :  // min default
                        dim->map_to_uint64(
                  start_str.data(), start_str.size(), bits, max_bucket_val);
      auto end_str = r->end_str();
      (*range_uint64)[d][1] =
          empty_end ? max_default :
                      dim->map_to_uint64(
                          end_str.data(), end_str.size(), bits, max_bucket_val);
    } else {
      // Note: coord_size is ignored for fixed size in map_to_uint64.
      (*range_uint64)[d][0] =
          empty_start ? 0 :  // min default
              dim->map_to_uint64(r->start_fixed(), 0, bits, max_bucket_val);
      (*range_uint64)[d][1] =
          empty_end ?
              max_default :
              dim->map_to_uint64(r->end_fixed(), 0, bits, max_bucket_val);
    }

    iassert((*range_uint64)[d][0] <= (*range_uint64)[d][1]);

    if ((*range_uint64)[d][0] != (*range_uint64)[d][1])
      *unsplittable = false;
  }
}