bool quiet = false;

bool verbose = false;

char buffer[256];

void log_message(const char* message, ...) {

if (quiet)

return;

std::time_t time;

std::size_t tail_index = strftime(buffer, sizeof(buffer), "%c: ", std::localtime(&time));

va_list args;

va_start(args, message);

std::vsnprintf(&buffer[tail_index], sizeof(buffer) - tail_index, message, args);

va_end(args);

std::printf("%s\n", buffer);

}

char const* key_begin = query_params.begin();

do {

key_begin = std::search(key_begin, query_params.end(), param_name.begin(), param_name.end());

if (key_begin == query_params.end())

return std::nullopt;

bool is_suffix = key_begin + param_name.size() == query_params.end();

if (is_suffix)

return std::string_view {};

// Check if we have matched a part of bigger key.

// In that case skip to next starting point.

auto prev_character = *(key_begin - 1);

if (prev_character != '?' && prev_character != '&' && prev_character != '/') {

key_begin += 1;

continue;

}

auto next_character = key_begin[param_name.size()];

if (next_character == '&')

return std::string_view {};

if (next_character == '=') {

auto value_begin = key_begin + param_name.size() + 1;

auto value_end = std::find(value_begin, query_params.end(), '&');

return std::string_view {value_begin, static_cast<size_t>(value_end - value_begin)};

}

key_begin += 1;

} while (true);

return std::nullopt;

if (uri.size() > name.size())

return uri.substr(0, name.size()) == name && uri[name.size()] == '?';

return uri == name;

// This is safe even in the form of a pointer comparison, doesn't have to be `std::strcmp`.

if (schema_ptr->format != ustore_doc_field_type_to_arrow_format(ustore_doc_field<ustore_collection_t>()))

return false;

if (column_ptr->null_count != 0)

return false;

return true;

// This is safe even in the form of a pointer comparison, doesn't have to be `std::strcmp`.

if (schema_ptr->format != ustore_doc_field_type_to_arrow_format(ustore_doc_field<ustore_key_t>()))

return false;

if (column_ptr->null_count != 0)

return false;

return true;

// This is safe even in the form of a pointer comparison, doesn't have to be `std::strcmp`.

if (schema_ptr->format != ustore_doc_field_type_to_arrow_format(ustore_doc_field<value_view_t>()))

return false;

if (column_ptr->null_count != 0)

return false;

return true;

std::unique_ptr<arf::Result> one_;

public:

SingleResultStream(std::unique_ptr<arf::Result>&& ptr) : one_(std::move(ptr)) {}

~SingleResultStream() {}

ar::Result<std::unique_ptr<arf::Result>> Next() override {

if (one_)

return std::exchange(one_, {});

else

return {nullptr};

}

public:

EmptyResultStream() {}

~EmptyResultStream() {}

ar::Result<std::unique_ptr<arf::Result>> Next() override { return {nullptr}; }

static_assert(!std::is_reference_v<scalar_at>);

auto result = std::make_unique<arf::Result>();

thread_local scalar_at scalar_copy;

scalar_copy = scalar;

result->body = std::make_shared<ar::Buffer>( //

reinterpret_cast<uint8_t const*>(&scalar_copy),

sizeof(scalar_copy));

auto results = std::make_unique<SingleResultStream>(std::move(result));

return std::unique_ptr<arf::ResultStream>(results.release());

// if (str.size() != 16 + 2)

// return default_;

// auto result = boost::lexical_cast<base_id_t>(str.data(), str.size());

// return result;

char* end = nullptr;

base_id_t result = std::strtoull(str.data(), &end, 16);

if (end != str.end())

return default_;

return result;

base_id_t result = default_;

std::from_chars(str.data(), str.data() + str.size(), result);

return result;

client_id_t client_id {0};

txn_id_t txn_id {0};

bool is_txn() const noexcept { return txn_id; }

bool operator==(session_id_t const& other) const noexcept {

return (client_id == other.client_id) & (txn_id == other.txn_id);

}

bool operator!=(session_id_t const& other) const noexcept {

return (client_id != other.client_id) | (txn_id != other.txn_id);

}

std::size_t operator()(session_id_t const& id) const noexcept {

std::size_t result = SIZE_MAX;

hash_combine(result, static_cast<base_id_t>(id.client_id));

hash_combine(result, static_cast<base_id_t>(id.txn_id));

return result;

}

ustore_transaction_t txn {};

ustore_arena_t arena {};

sys_time_t last_access {};

bool executing {};

client_to_txn_t const& sessions;

bool operator()(session_id_t const& a, session_id_t const& b) const noexcept {

return sessions.at(a).last_access > sessions.at(b).last_access;

}

sessions_t& sessions;

session_id_t session_id;

ustore_transaction_t txn = nullptr;

ustore_arena_t arena = nullptr;

bool is_txn() const noexcept { return txn; }

~session_lock_t() noexcept;

std::mutex mutex_;

// Reusable object handles:

std::vector<ustore_arena_t> free_arenas_;

std::vector<ustore_transaction_t> free_txns_;

/// Links each session to memory used for its operations:

client_to_txn_t client_to_txn_;

ustore_database_t db_ = nullptr;

// On Postgre 9.6+ is set to same 30 seconds.

std::size_t milliseconds_timeout = 30'000;

running_txn_t pop(ustore_error_t* c_error) noexcept {

auto it = std::min_element(client_to_txn_.begin(), client_to_txn_.end(), [](auto left, auto right) {

return left.second.last_access < right.second.last_access && !left.second.executing;

});

auto age = std::chrono::duration_cast<std::chrono::milliseconds>(it->second.last_access - sys_clock_t::now());

if (age.count() < milliseconds_timeout || it->second.executing) {

log_error_m(c_error, error_unknown_k, "Too many concurrent sessions");

return {};

}

running_txn_t released = it->second;

client_to_txn_.erase(it);

released.executing = false;

return released;

}

void submit(session_id_t session_id, running_txn_t running_txn) noexcept {

running_txn.executing = false;

auto res = client_to_txn_.insert_or_assign(session_id, running_txn);

}

public:

sessions_t(ustore_database_t db, std::size_t n) : db_(db), free_arenas_(n), free_txns_(n), client_to_txn_(n) {

std::fill_n(free_arenas_.begin(), n, nullptr);

std::fill_n(free_txns_.begin(), n, nullptr);

}

~sessions_t() noexcept {

for (auto a : free_arenas_)

ustore_arena_free(a);

for (auto t : free_txns_)

ustore_transaction_free(t);

}

running_txn_t continue_txn(session_id_t session_id, ustore_error_t* c_error) noexcept {

std::unique_lock _ {mutex_};

auto it = client_to_txn_.find(session_id);

if (it == client_to_txn_.end()) {

log_error_m(c_error, args_wrong_k, "Transaction was terminated, start a new one");

return {};

}

running_txn_t& running = it->second;

if (running.executing) {

log_error_m(c_error, args_wrong_k, "Transaction can't be modified concurrently.");

return {};

}

running.executing = true;

running.last_access = sys_clock_t::now();

// Update the heap order.

// With a single change shouldn't take more than `log2(n)` operations.

return running;

}

running_txn_t request_txn(session_id_t session_id, ustore_error_t* c_error) noexcept {

std::unique_lock _ {mutex_};

auto it = client_to_txn_.find(session_id);

if (it != client_to_txn_.end()) {

log_error_m(c_error, args_wrong_k, "Such transaction is already running, just continue using it.");

return {};

}

// Consider evicting some of the old sessions, if there are no more empty slots

if (free_txns_.empty() || free_arenas_.empty()) {

running_txn_t running = pop(c_error);

if (*c_error)

return {};

running.executing = true;

running.last_access = sys_clock_t::now();

return running;

}

// If we have free slots

running_txn_t running {};

running.arena = free_arenas_.back();

running.txn = free_txns_.back();

running.executing = true;

running.last_access = sys_clock_t::now();

free_arenas_.pop_back();

free_txns_.pop_back();

return running;

}

void hold_txn(session_id_t session_id, running_txn_t running_txn) noexcept {

std::unique_lock _ {mutex_};

submit(session_id, running_txn);

}

void release_txn(running_txn_t running_txn) noexcept {

std::unique_lock _ {mutex_};

free_arenas_.push_back(running_txn.arena);

free_txns_.push_back(running_txn.txn);

}

void release_txn(session_id_t session_id) noexcept {

std::unique_lock _ {mutex_};

auto it = client_to_txn_.find(session_id);

if (it == client_to_txn_.end())

return;

it->second.executing = false;

free_arenas_.push_back(it->second.arena);

free_txns_.push_back(it->second.txn);

client_to_txn_.erase(it);

}

ustore_arena_t request_arena(ustore_error_t* c_error) noexcept {

std::unique_lock _ {mutex_};

// Consider evicting some of the old sessions, if there are no more empty slots

if (free_arenas_.empty()) {

running_txn_t running = pop(c_error);

if (*c_error)

return nullptr;

free_txns_.push_back(running.txn);

return running.arena;

}

ustore_arena_t arena = free_arenas_.back();

free_arenas_.pop_back();

return arena;

}

void release_arena(ustore_arena_t arena) noexcept {

std::unique_lock _ {mutex_};

free_arenas_.push_back(arena);

}

session_lock_t lock(session_id_t id, ustore_error_t* c_error) noexcept {

if (id.is_txn()) {

running_txn_t running = continue_txn(id, c_error);

return {*this, id, running.txn, running.arena};

}

else

return {*this, id, nullptr, request_arena(c_error)};

}

session_id_t session_id;

std::optional<std::string_view> transaction_id;

std::optional<std::string_view> snapshot_id;

std::optional<std::string_view> collection_name;

std::optional<std::string_view> collection_id;

std::optional<std::string_view> collection_drop_mode;

std::optional<std::string_view> read_part;

std::optional<std::string_view> opt_snapshot;

std::optional<std::string_view> opt_flush;

std::optional<std::string_view> opt_dont_watch;

std::optional<std::string_view> opt_shared_memory;

std::optional<std::string_view> opt_dont_discard_memory;

session_params_t result;

result.session_id.client_id = parse_client_id(server_call);

auto params_offs = uri.find('?');

if (params_offs == std::string_view::npos)

return result;

auto params = uri.substr(params_offs);

result.transaction_id = param_value(params, kParamTransactionID);

if (result.transaction_id)

result.session_id.txn_id = parse_txn_id(*result.transaction_id);

result.snapshot_id = param_value(params, kParamSnapshotID);

result.collection_name = param_value(params, kParamCollectionName);

result.collection_id = param_value(params, kParamCollectionID);

result.collection_drop_mode = param_value(params, kParamDropMode);

result.read_part = param_value(params, kParamReadPart);

result.opt_flush = param_value(params, kParamFlagFlushWrite);

result.opt_dont_watch = param_value(params, kParamFlagDontWatch);

result.opt_shared_memory = param_value(params, kParamFlagSharedMemRead);

// This flag shouldn't have been forwarded to the server.

// In standalone builds it remains on the client.

// result.opt_dont_discard_memory = param_value(params, kParamFlagDontDiscard);

return result;

ustore_options_t result = ustore_options_default_k;

if (params.opt_dont_watch)

result = ustore_options_t(result | ustore_option_transaction_dont_watch_k);

if (params.opt_flush)

result = ustore_options_t(result | ustore_option_write_flush_k);

if (params.opt_shared_memory)

result = ustore_options_t(result | ustore_option_read_shared_memory_k);

return result;

ustore_str_view_t collection_config = reinterpret_cast<ustore_str_view_t>(buf.data());

auto end_config = collection_config + buf.capacity();

return std::find(collection_config, end_config, '\0') == end_config ? nullptr : collection_config;

database_t db_;

sessions_t sessions_;

public:

UStoreService(database_t&& db, std::size_t capacity = 4096) : db_(std::move(db)), sessions_(db_, capacity) {}

~UStoreService() { db_.close(); }

ar::Status ListActions( //

arf::ServerCallContext const&,

std::vector<arf::ActionType>* actions) override {

*actions = {

kActionColOpen,

kActionColDrop,

kActionSnapOpen,

kActionSnapExport,

kActionSnapDrop,

kActionTxnBegin,

kActionTxnCommit,

};

return ar::Status::OK();

}

ar::Status ListFlights( //

arf::ServerCallContext const&,

arf::Criteria const*,

std::unique_ptr<arf::FlightListing>*) override {

return ar::Status::OK();

}

ar::Status GetFlightInfo( //

arf::ServerCallContext const&,

arf::FlightDescriptor const&,

std::unique_ptr<arf::FlightInfo>*) override {

// ARROW_ASSIGN_OR_RAISE(auto file_info, FileInfoFromDescriptor(descriptor));

// ARROW_ASSIGN_OR_RAISE(auto flight_info, MakeFlightInfo(file_info));

// *info = std::make_unique<arf::FlightInfo>(std::move(flight_info));

return ar::Status::OK();

}

ar::Status GetSchema( //

arf::ServerCallContext const&,

arf::FlightDescriptor const&,

std::unique_ptr<arf::SchemaResult>*) override {

return ar::Status::OK();

}

ar::Status DoAction( //

arf::ServerCallContext const& server_call,

arf::Action const& action,

std::unique_ptr<arf::ResultStream>* results_ptr) override {

ar::Status ar_status;

session_params_t params = session_params(server_call, action.type);

status_t status;

// Locating the collection ID

if (is_query(action.type, kActionColOpen.type)) {

log_message_if_verbose_m("Action start: Collection create");

if (!params.collection_name)

log_return_message_m(ar::Status::Invalid, "Missing collection name argument");

// The name must be null-terminated.

// This is not safe:

ustore_str_span_t c_collection_name = nullptr;

c_collection_name = (ustore_str_span_t)params.collection_name->begin();

c_collection_name[params.collection_name->size()] = 0;

ustore_collection_t collection_id = 0;

ustore_str_view_t collection_config = get_null_terminated(action.body);

ustore_collection_create_t collection_init {};

collection_init.db = db_;

collection_init.error = status.member_ptr();

collection_init.name = params.collection_name->begin();

collection_init.config = collection_config;

collection_init.id = &collection_id;

ustore_collection_create(&collection_init);

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

*results_ptr = return_scalar<ustore_collection_t>(collection_id);

log_message_if_verbose_m("Action end: Collection create");

return ar::Status::OK();

}

// Dropping a collection

if (is_query(action.type, kActionColDrop.type)) {

log_message_if_verbose_m("Action start: Collection drop");

if (!params.collection_id)

log_return_message_m(ar::Status::Invalid, "Missing collection ID argument");

ustore_drop_mode_t mode = //

params.collection_drop_mode == kParamDropModeValues //

? ustore_drop_vals_k

: params.collection_drop_mode == kParamDropModeContents //

? ustore_drop_keys_vals_k

: ustore_drop_keys_vals_handle_k;

ustore_collection_t c_collection_id = ustore_collection_main_k;

if (params.collection_id)

c_collection_id = parse_u64_hex(*params.collection_id, ustore_collection_main_k);

ustore_collection_drop_t collection_drop {};

collection_drop.db = db_;

collection_drop.error = status.member_ptr();

collection_drop.id = c_collection_id;

collection_drop.mode = mode;

ustore_collection_drop(&collection_drop);

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

*results_ptr = return_empty();

log_message_if_verbose_m("Action end: Collection drop");

return ar::Status::OK();

}

// Create a snapshot

if (is_query(action.type, kActionSnapOpen.type)) {

log_message_if_verbose_m("Action start: Snapshot create");

if (params.snapshot_id)

log_return_message_m(ar::Status::Invalid, "Missing snapshot ID argument");

ustore_snapshot_t snapshot_id = 0;

ustore_snapshot_create_t snapshot_create {

.db = db_,

.error = status.member_ptr(),

.id = &snapshot_id,

};

ustore_snapshot_create(&snapshot_create);

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

*results_ptr = return_scalar<ustore_snapshot_t>(snapshot_id);

log_message_if_verbose_m("Action end: Snapshot create");

return ar::Status::OK();

}

// Export a snapshot

if (is_query(action.type, kActionSnapExport.type)) {

log_message_if_verbose_m("Action start: Snapshot export");

if (params.snapshot_id)

log_return_message_m(ar::Status::Invalid, "Missing snapshot ID argument");

ustore_str_span_t c_export_path = nullptr;

ustore_snapshot_t c_snapshot_id = 0;

if (params.snapshot_id)

c_snapshot_id = parse_snap_id(*params.snapshot_id);

ustore_snapshot_export_t snapshot_export {

.db = db_,

.error = status.member_ptr(),

.id = c_snapshot_id,

.path = c_export_path,

};

ustore_snapshot_export(&snapshot_export);

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

*results_ptr = return_empty();

log_message_if_verbose_m("Action end: Snapshot export");

return ar::Status::OK();

}

// Dropping a snapshot

if (is_query(action.type, kActionSnapDrop.type)) {

log_message_if_verbose_m("Action start: Snapshot drop");

if (!params.snapshot_id)

log_return_message_m(ar::Status::Invalid, "Missing snapshot ID argument");

ustore_snapshot_t c_snapshot_id = 0;

if (params.snapshot_id)

c_snapshot_id = parse_snap_id(*params.snapshot_id);

ustore_snapshot_drop_t snapshot_drop {

.db = db_,

.error = status.member_ptr(),

.id = c_snapshot_id,

};

ustore_snapshot_drop(&snapshot_drop);

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

*results_ptr = return_empty();

log_message_if_verbose_m("Action end: Snapshot drop");

return ar::Status::OK();

}

// Starting a transaction

if (is_query(action.type, kActionTxnBegin.type)) {

log_message_if_verbose_m("Action start: Transaction create");

if (!params.transaction_id)

params.session_id.txn_id = static_cast<txn_id_t>(std::rand());

// Request handles for memory

running_txn_t session = sessions_.request_txn(params.session_id, status.member_ptr());

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

// Cleanup internal state

ustore_transaction_init_t txn_init {};

txn_init.db = db_;

txn_init.error = status.member_ptr();

txn_init.options = ustore_options(params);

txn_init.transaction = &session.txn;

ustore_transaction_init(&txn_init);

if (!status) {

sessions_.release_txn(params.session_id);

log_return_message_m(ar::Status::ExecutionError, status.message());

}

// Don't forget to add the transaction to active sessions

sessions_.hold_txn(params.session_id, session);

*results_ptr = return_scalar<txn_id_t>(params.session_id.txn_id);

log_message_if_verbose_m("Action end: Transaction create");

return ar::Status::OK();

}

if (is_query(action.type, kActionTxnCommit.type)) {

log_message_if_verbose_m("Action start: Transaction commit");

if (!params.transaction_id)

log_return_message_m(ar::Status::Invalid, "Missing transaction ID argument");

running_txn_t session = sessions_.continue_txn(params.session_id, status.member_ptr());

if (!status) {

sessions_.release_txn(params.session_id);

log_return_message_m(ar::Status::ExecutionError, status.message());

}

ustore_transaction_commit_t txn_commit {};

txn_commit.db = db_;

txn_commit.error = status.member_ptr();

txn_commit.transaction = session.txn;

txn_commit.options = ustore_options(params);

ustore_transaction_commit(&txn_commit);

if (!status) {

sessions_.release_txn(params.session_id);

log_return_message_m(ar::Status::ExecutionError, status.message());

}

sessions_.release_txn(params.session_id);

*results_ptr = return_empty();

log_message_if_verbose_m("Action end: Transaction commit");

return ar::Status::OK();

}

logger.log_message("Unknown action type: %s", action.type.c_str());

log_return_message_m(ar::Status::NotImplemented, "Unknown action type: ", action.type);

}

ar::Status DoExchange( //

arf::ServerCallContext const& server_call,

std::unique_ptr<arf::FlightMessageReader> request_ptr,

std::unique_ptr<arf::FlightMessageWriter> response_ptr) override {

ar::Status ar_status;

arf::FlightMessageReader& request = *request_ptr;

arf::FlightMessageWriter& response = *response_ptr;

arf::FlightDescriptor const& desc = request.descriptor();

session_params_t params = session_params(server_call, desc.cmd);

status_t status;

ArrowSchema input_schema_c, output_schema_c;

ArrowArray input_batch_c, output_batch_c;

if (ar_status = unpack_table(request.ToTable(), input_schema_c, input_batch_c); !ar_status.ok())

return ar_status;

bool is_empty_values = false;

/// @param `collections`

ustore_collection_t c_collection_id = ustore_collection_main_k;

strided_iterator_gt<ustore_collection_t> input_collections;

if (params.collection_id) {

c_collection_id = parse_u64_hex(*params.collection_id, ustore_collection_main_k);

input_collections = strided_iterator_gt<ustore_collection_t> {&c_collection_id};

}

else

input_collections = get_collections(input_schema_c, input_batch_c, kArgCols);

ustore_snapshot_t c_snapshot_id = 0;

if (params.snapshot_id)

c_snapshot_id = parse_snap_id(*params.snapshot_id);

// Reserve resources for the execution of this request

auto session = sessions_.lock(params.session_id, status.member_ptr());

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

if (is_query(desc.cmd, kFlightRead)) {

log_message_if_verbose_m("Process start: Read");

/// @param `keys`

auto input_keys = get_keys(input_schema_c, input_batch_c, kArgKeys);

if (!input_keys)

log_return_message_m(ar::Status::Invalid, "Keys must have been provided for reads");

bool const request_only_presences = params.read_part == kParamReadPartPresences;

bool const request_only_lengths = params.read_part == kParamReadPartLengths;

bool const request_content = !request_only_lengths && !request_only_presences;

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

// As we are immediately exporting in the Arrow format,

// we don't need the lengths, just the NULL indicators

ustore_bytes_ptr_t found_values = nullptr;

ustore_length_t* found_offsets = nullptr;

ustore_length_t* found_lengths = nullptr;

ustore_octet_t* found_presences = nullptr;

ustore_size_t tasks_count = static_cast<ustore_size_t>(input_batch_c.length);

log_message_if_verbose_m("Reading %zu key", tasks_count);

ustore_read_t read {};

read.db = db_;

read.error = status.member_ptr();

read.transaction = session.txn;

read.snapshot = c_snapshot_id;

read.arena = &session.arena;

read.options = ustore_options(params);

read.tasks_count = tasks_count;

read.collections = input_collections.get();

read.collections_stride = input_collections.stride();

read.keys = input_keys.get();

read.keys_stride = input_keys.stride();

read.presences = &found_presences;

read.offsets = request_content ? &found_offsets : nullptr;

read.lengths = request_only_lengths ? &found_lengths : nullptr;

read.values = request_content ? &found_values : nullptr;

ustore_read(&read);

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

is_empty_values = request_content && (found_values == nullptr);

ustore_size_t result_length =

request_only_presences ? divide_round_up<ustore_size_t>(tasks_count, CHAR_BIT) : tasks_count;

ustore_to_arrow_schema(result_length, 1, &output_schema_c, &output_batch_c, status.member_ptr());

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

if (request_content)

ustore_to_arrow_column( //

result_length,

kArgVals.c_str(),

ustore_doc_field_bin_k,

found_presences,

found_offsets,

found_values,

output_schema_c.children[0],

output_batch_c.children[0],

status.member_ptr());

else if (request_only_lengths)

ustore_to_arrow_column( //

result_length,

kArgLengths.c_str(),

ustore_doc_field<ustore_length_t>(),

found_presences,

nullptr,

found_lengths,

output_schema_c.children[0],

output_batch_c.children[0],

status.member_ptr());

else if (request_only_presences)

ustore_to_arrow_column( //

result_length,

kArgPresences.c_str(),

ustore_doc_field<ustore_octet_t>(),

nullptr,

nullptr,

found_presences,

output_schema_c.children[0],

output_batch_c.children[0],

status.member_ptr());

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

log_message_if_verbose_m("Process end: Read");

}

else if (is_query(desc.cmd, kFlightReadPath)) {

log_message_if_verbose_m("Process start: Read path");

/// @param `keys`

auto input_paths = get_contents(input_schema_c, input_batch_c, kArgPaths.c_str());

if (!input_paths.contents_begin)

log_return_message_m(ar::Status::Invalid, "Keys must have been provided for reads");

bool const request_only_presences = params.read_part == kParamReadPartPresences;

bool const request_only_lengths = params.read_part == kParamReadPartLengths;

bool const request_content = !request_only_lengths && !request_only_presences;

// As we are immediately exporting in the Arrow format,

// we don't need the lengths, just the NULL indicators

ustore_bytes_ptr_t found_values = nullptr;

ustore_length_t* found_offsets = nullptr;

ustore_length_t* found_lengths = nullptr;

ustore_octet_t* found_presences = nullptr;

ustore_size_t tasks_count = static_cast<ustore_size_t>(input_batch_c.length);

log_message_if_verbose_m("Reading %zu path", tasks_count);

ustore_paths_read_t read {};

read.db = db_;

read.error = status.member_ptr();

read.transaction = session.txn;

read.arena = &session.arena;

read.options = ustore_options(params);

read.tasks_count = tasks_count;

read.path_separator = input_paths.separator;

read.collections = input_collections.get();

read.collections_stride = input_collections.stride();

read.paths = reinterpret_cast<ustore_str_view_t const*>(input_paths.contents_begin.get());

read.paths_stride = input_paths.contents_begin.stride();

read.paths_offsets = input_paths.offsets_begin.get();

read.paths_offsets_stride = input_paths.offsets_begin.stride();

read.paths_lengths = input_paths.lengths_begin.get();

read.paths_lengths_stride = input_paths.lengths_begin.stride();

read.presences = &found_presences;

read.offsets = request_content ? &found_offsets : nullptr;

read.lengths = request_only_lengths ? &found_lengths : nullptr;

read.values = request_content ? &found_values : nullptr;

ustore_paths_read(&read);

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

ustore_size_t result_length =

request_only_presences ? divide_round_up<ustore_size_t>(tasks_count, CHAR_BIT) : tasks_count;

ustore_to_arrow_schema(result_length, 1, &output_schema_c, &output_batch_c, status.member_ptr());

if (!status)

log_return_message_m(ar::Status::ExecutionError, status.message());

if (request_content)

ustore_to_arrow_column( //

result_length,

kArgVals.c_str(),

ustore_doc_field_bin_k,

found_presences,

found_offsets,

found_values,

output_schema_c.children[0],

output_batch_c.children[0],

status.member_ptr());

else if (request_only_lengths)

ustore_to_arrow_column( //

result_length,

kArgLengths.c_str(),

ustore_doc_field<ustore_length_t>(),

found_presences,

nullptr,

found_lengths,