diff --git a/test/src/unit-cppapi-partial-attribute-write.cc b/test/src/unit-cppapi-partial-attribute-write.cc index cc4b2736302..e4909296df1 100644 --- a/test/src/unit-cppapi-partial-attribute-write.cc +++ b/test/src/unit-cppapi-partial-attribute-write.cc @@ -315,7 +315,7 @@ TEST_CASE_METHOD( // Try to rewrite an attribute, will throw an exception. CHECK_THROWS_WITH( write_sparse_a1(*query, {8, 9, 10, 11, 12, 13, 14, 15}), - "[TileDB::Query] Error: Buffer a1 was already written"); + "Query: Buffer a1 was already written"); write_sparse_a2(*query, {8, 9, 10, 11, 12, 13, 14, 15}); diff --git a/test/src/unit-enumerations.cc b/test/src/unit-enumerations.cc index 73ea8ed8f38..630dd9b040f 100644 --- a/test/src/unit-enumerations.cc +++ b/test/src/unit-enumerations.cc @@ -2488,7 +2488,7 @@ TEST_CASE_METHOD( ctx_.cancellation_source(), ctx_.storage_manager(), array); - throw_if_not_ok(q1.set_condition(qc1)); + q1.set_condition(qc1); Query q2( ctx_.resources(), @@ -2532,7 +2532,7 @@ TEST_CASE_METHOD( ctx_.cancellation_source(), ctx_.storage_manager(), array); - throw_if_not_ok(q1.set_condition(qc3)); + q1.set_condition(qc3); Query q2( ctx_.resources(), diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index d89ccd4da3e..c8c54cbff40 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -3603,9 +3603,7 @@ void CSparseGlobalOrderFx::run_execute(Instance& instance) { 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"); + query->query_->set_condition(qc); // SAFETY: this performs a deep copy } // Prepare output buffer diff --git a/tiledb/sm/c_api/tiledb.cc b/tiledb/sm/c_api/tiledb.cc index 17024029f7a..8e7e3c72180 100644 --- a/tiledb/sm/c_api/tiledb.cc +++ b/tiledb/sm/c_api/tiledb.cc @@ -470,7 +470,7 @@ int32_t tiledb_query_set_data_buffer( return TILEDB_ERR; // Set attribute buffer - throw_if_not_ok(query->query_->set_data_buffer(name, buffer, buffer_size)); + query->query_->set_data_buffer(name, buffer, buffer_size); return TILEDB_OK; } @@ -485,8 +485,7 @@ int32_t tiledb_query_set_offsets_buffer( return TILEDB_ERR; // Set attribute buffer - throw_if_not_ok(query->query_->set_offsets_buffer( - name, buffer_offsets, buffer_offsets_size)); + query->query_->set_offsets_buffer(name, buffer_offsets, buffer_offsets_size); return TILEDB_OK; } @@ -501,8 +500,8 @@ int32_t tiledb_query_set_validity_buffer( return TILEDB_ERR; // Set attribute buffer - throw_if_not_ok(query->query_->set_validity_buffer( - name, buffer_validity, buffer_validity_size)); + query->query_->set_validity_buffer( + name, buffer_validity, buffer_validity_size); return TILEDB_OK; } @@ -518,7 +517,7 @@ int32_t tiledb_query_get_data_buffer( return TILEDB_ERR; // Get attribute buffer - throw_if_not_ok(query->query_->get_data_buffer(name, buffer, buffer_size)); + std::tie(*buffer, *buffer_size) = query->query_->get_data_buffer(name); return TILEDB_OK; } @@ -534,7 +533,7 @@ int32_t tiledb_query_get_offsets_buffer( return TILEDB_ERR; // Get attribute buffer - throw_if_not_ok(query->query_->get_offsets_buffer(name, buffer, buffer_size)); + std::tie(*buffer, *buffer_size) = query->query_->get_offsets_buffer(name); return TILEDB_OK; } @@ -550,8 +549,7 @@ int32_t tiledb_query_get_validity_buffer( return TILEDB_ERR; // Get attribute buffer - throw_if_not_ok( - query->query_->get_validity_buffer(name, buffer, buffer_size)); + std::tie(*buffer, *buffer_size) = query->query_->get_validity_buffer(name); return TILEDB_OK; } @@ -563,8 +561,7 @@ int32_t tiledb_query_set_layout( return TILEDB_ERR; // Set layout - throw_if_not_ok( - query->query_->set_layout(static_cast(layout))); + query->query_->set_layout(static_cast(layout)); return TILEDB_OK; } @@ -579,7 +576,7 @@ int32_t tiledb_query_set_condition( return TILEDB_ERR; // Set layout - throw_if_not_ok(query->query_->set_condition(*cond->query_condition_)); + query->query_->set_condition(*cond->query_condition_); return TILEDB_OK; } @@ -594,7 +591,7 @@ int32_t tiledb_query_finalize(tiledb_ctx_t* ctx, tiledb_query_t* query) { return TILEDB_ERR; // Flush query - throw_if_not_ok(query->query_->finalize()); + query->query_->finalize(); return TILEDB_OK; } @@ -609,7 +606,7 @@ int32_t tiledb_query_submit_and_finalize( if (sanity_check(ctx, query) == TILEDB_ERR) return TILEDB_ERR; - throw_if_not_ok(query->query_->submit_and_finalize()); + query->query_->submit_and_finalize(); return TILEDB_OK; } @@ -627,7 +624,7 @@ int32_t tiledb_query_submit(tiledb_ctx_t* ctx, tiledb_query_t* query) { if (sanity_check(ctx, query) == TILEDB_ERR) return TILEDB_ERR; - throw_if_not_ok(query->query_->submit()); + query->query_->submit(); return TILEDB_OK; } @@ -786,7 +783,7 @@ int32_t tiledb_query_get_fragment_num( if (sanity_check(ctx, query) == TILEDB_ERR) return TILEDB_ERR; - throw_if_not_ok(query->query_->get_written_fragment_num(num)); + *num = query->query_->get_written_fragment_num(); return TILEDB_OK; } @@ -799,7 +796,7 @@ int32_t tiledb_query_get_fragment_uri( if (sanity_check(ctx, query) == TILEDB_ERR) return TILEDB_ERR; - throw_if_not_ok(query->query_->get_written_fragment_uri(idx, uri)); + *uri = query->query_->get_written_fragment_uri(idx).c_str(); return TILEDB_OK; } @@ -813,8 +810,7 @@ int32_t tiledb_query_get_fragment_timestamp_range( if (sanity_check(ctx, query) == TILEDB_ERR) return TILEDB_ERR; - throw_if_not_ok( - query->query_->get_written_fragment_timestamp_range(idx, t1, t2)); + std::tie(*t1, *t2) = query->query_->get_written_fragment_timestamp_range(idx); return TILEDB_OK; } @@ -855,13 +851,7 @@ int32_t tiledb_query_add_update_value( return TILEDB_ERR; } - // Add update value. - if (SAVE_ERROR_CATCH( - ctx, - query->query_->add_update_value( - field_name, update_value, update_value_size))) { - return TILEDB_ERR; - } + query->query_->add_update_value(field_name, update_value, update_value_size); // Success return TILEDB_OK; diff --git a/tiledb/sm/c_api/tiledb_filestore.cc b/tiledb/sm/c_api/tiledb_filestore.cc index d39c2ac7462..145bf2d79a4 100644 --- a/tiledb/sm/c_api/tiledb_filestore.cc +++ b/tiledb/sm/c_api/tiledb_filestore.cc @@ -263,7 +263,7 @@ int32_t tiledb_filestore_uri_import( context.cancellation_source(), context.storage_manager(), array); - throw_if_not_ok(query.set_layout(tiledb::sm::Layout::GLOBAL_ORDER)); + query.set_layout(tiledb::sm::Layout::GLOBAL_ORDER); std::vector buffer(buffer_size); tiledb::sm::Subarray subarray( @@ -289,7 +289,7 @@ int32_t tiledb_filestore_uri_import( context.cancellation_source(), context.storage_manager(), array); - throw_if_not_ok(query.set_layout(tiledb::sm::Layout::ROW_MAJOR)); + query.set_layout(tiledb::sm::Layout::ROW_MAJOR); tiledb::sm::Subarray subarray_cloud_fix( array.get(), nullptr, context.resources().logger(), true); @@ -299,11 +299,11 @@ int32_t tiledb_filestore_uri_import( subarray_cloud_fix.add_range(0, std::move(subarray_range_cloud_fix)); query.set_subarray(subarray_cloud_fix); uint64_t data_buff_len = end - start + 1; - throw_if_not_ok(query.set_data_buffer( + query.set_data_buffer( tiledb::sm::constants::filestore_attribute_name, buffer.data(), - &data_buff_len)); - throw_if_not_ok(query.submit()); + &data_buff_len); + query.submit(); }; auto read_wrapper = @@ -336,11 +336,11 @@ int32_t tiledb_filestore_uri_import( if (is_tiledb_uri) { tiledb_cloud_fix(start_range, end_cloud_fix); } else { - throw_if_not_ok(query.set_data_buffer( + query.set_data_buffer( tiledb::sm::constants::filestore_attribute_name, buffer.data(), - &query_buffer_len)); - throw_if_not_ok(query.submit()); + &query_buffer_len); + query.submit(); } start_range += readlen; @@ -355,7 +355,7 @@ int32_t tiledb_filestore_uri_import( if (!is_tiledb_uri) { // Dump the fragment on disk - throw_if_not_ok(query.finalize()); + query.finalize(); } throw_if_not_ok(vfs.close_file(tiledb::sm::URI(file_uri))); @@ -422,7 +422,7 @@ int32_t tiledb_filestore_uri_export( context.cancellation_source(), context.storage_manager(), array); - throw_if_not_ok(query.set_layout(tiledb::sm::Layout::ROW_MAJOR)); + query.set_layout(tiledb::sm::Layout::ROW_MAJOR); query.set_subarray(subarray); // Cloud compatibility hack. Currently stored tiledb file arrays have a @@ -435,17 +435,17 @@ int32_t tiledb_filestore_uri_export( ->attribute(tiledb::sm::constants::filestore_attribute_name) ->type(); if (attr_type == tiledb::sm::Datatype::UINT8) { - throw_if_not_ok(query.set_data_buffer( + query.set_data_buffer( tiledb::sm::constants::filestore_attribute_name, reinterpret_cast(data.data()), - &write_size)); + &write_size); } else { - throw_if_not_ok(query.set_data_buffer( + query.set_data_buffer( tiledb::sm::constants::filestore_attribute_name, data.data(), - &write_size)); + &write_size); } - throw_if_not_ok(query.submit()); + query.submit(); vfs.write( tiledb::sm::URI(file_uri), @@ -528,7 +528,7 @@ int32_t tiledb_filestore_buffer_import( context.cancellation_source(), context.storage_manager(), array); - throw_if_not_ok(query.set_layout(tiledb::sm::Layout::ROW_MAJOR)); + query.set_layout(tiledb::sm::Layout::ROW_MAJOR); tiledb::sm::Subarray subarray( array.get(), nullptr, context.resources().logger(), true); @@ -540,9 +540,9 @@ int32_t tiledb_filestore_buffer_import( query.set_subarray(subarray); uint64_t size_tmp = size; - throw_if_not_ok(query.set_data_buffer( - tiledb::sm::constants::filestore_attribute_name, buf, &size_tmp)); - throw_if_not_ok(query.submit()); + query.set_data_buffer( + tiledb::sm::constants::filestore_attribute_name, buf, &size_tmp); + query.submit(); throw_if_not_ok(array->close()); @@ -601,12 +601,12 @@ int32_t tiledb_filestore_buffer_export( context.cancellation_source(), context.storage_manager(), array); - throw_if_not_ok(query.set_layout(tiledb::sm::Layout::ROW_MAJOR)); + query.set_layout(tiledb::sm::Layout::ROW_MAJOR); query.set_subarray(subarray); uint64_t size_tmp = size; - throw_if_not_ok(query.set_data_buffer( - tiledb::sm::constants::filestore_attribute_name, buf, &size_tmp)); - throw_if_not_ok(query.submit()); + query.set_data_buffer( + tiledb::sm::constants::filestore_attribute_name, buf, &size_tmp); + query.submit(); throw_if_not_ok(array->close()); diff --git a/tiledb/sm/consolidator/fragment_consolidator.cc b/tiledb/sm/consolidator/fragment_consolidator.cc index db6f9bcad4d..8d18fa2291c 100644 --- a/tiledb/sm/consolidator/fragment_consolidator.cc +++ b/tiledb/sm/consolidator/fragment_consolidator.cc @@ -661,16 +661,17 @@ Status FragmentConsolidator::consolidate_internal( // Read from one array and write to the other copy_array(query_r.get(), query_w.get(), cw); - // Finalize write query - auto st = query_w->finalize(); - if (!st.ok()) { + try { + // Finalize write query + query_w->finalize(); + } catch (...) { if (resources_.vfs().is_dir(*new_fragment_uri)) resources_.vfs().remove_dir(*new_fragment_uri); - return st; + throw; } // Write vacuum file - st = write_vacuum_file( + auto st = write_vacuum_file( array_for_reads->array_schema_latest().write_version(), array_for_reads->array_uri(), vac_uri, @@ -696,7 +697,7 @@ void FragmentConsolidator::copy_array( do { // READ - throw_if_not_ok(query_r->submit()); + query_r->submit(); // If Consolidation cannot make any progress, throw. The first buffer will // always contain fixed size data, whether it is tile offsets for var size @@ -712,7 +713,7 @@ void FragmentConsolidator::copy_array( set_query_buffers(query_w, cw); // WRITE - throw_if_not_ok(query_w->submit()); + query_w->submit(); } while (query_r->status() == QueryStatus::INCOMPLETE); } @@ -742,7 +743,7 @@ Status FragmentConsolidator::create_queries( array_for_reads, nullopt, read_memory_budget)); - throw_if_not_ok(query_r->set_layout(Layout::GLOBAL_ORDER)); + query_r->set_layout(Layout::GLOBAL_ORDER); // Dense consolidation will do a tile aligned read. if (dense) { @@ -750,12 +751,12 @@ Status FragmentConsolidator::create_queries( auto& domain{array_for_reads->array_schema_latest().domain()}; array_for_reads->array_schema_latest().current_domain().expand_to_tiles( domain, read_subarray); - throw_if_not_ok(query_r->set_subarray_unsafe(read_subarray)); + query_r->set_subarray_unsafe(read_subarray); } // Enable consolidation with timestamps on the reader, if applicable. if (config_.with_timestamps_ && !dense) { - throw_if_not_ok(query_r->set_consolidation_with_timestamps()); + query_r->set_consolidation_with_timestamps(); } // Get last fragment URI, which will be the URI of the consolidated fragment @@ -775,11 +776,11 @@ Status FragmentConsolidator::create_queries( array_for_writes, fragment_name, write_memory_budget)); - throw_if_not_ok(query_w->set_layout(Layout::GLOBAL_ORDER)); - throw_if_not_ok(query_w->disable_checks_consolidation()); + query_w->set_layout(Layout::GLOBAL_ORDER); + query_w->disable_checks_consolidation(); query_w->set_fragment_size(config_.max_fragment_size_); if (array_for_reads->array_schema_latest().dense()) { - throw_if_not_ok(query_w->set_subarray_unsafe(subarray)); + query_w->set_subarray_unsafe(subarray); } // Set the processed conditions on new fragment. @@ -932,29 +933,25 @@ void FragmentConsolidator::set_query_buffers( // were written or not. for (const auto& attr : attributes) { if (!attr->var_size()) { - throw_if_not_ok(query->set_data_buffer( - attr->name(), (void*)&(*buffers)[bid][0], &(*buffer_sizes)[bid])); + query->set_data_buffer( + attr->name(), (void*)&(*buffers)[bid][0], &(*buffer_sizes)[bid]); ++bid; if (attr->nullable()) { - throw_if_not_ok(query->set_validity_buffer( - attr->name(), - (uint8_t*)&(*buffers)[bid][0], - &(*buffer_sizes)[bid])); + query->set_validity_buffer( + attr->name(), (uint8_t*)&(*buffers)[bid][0], &(*buffer_sizes)[bid]); ++bid; } } else { - throw_if_not_ok(query->set_data_buffer( + query->set_data_buffer( attr->name(), (void*)&(*buffers)[bid + 1][0], - &(*buffer_sizes)[bid + 1])); - throw_if_not_ok(query->set_offsets_buffer( - attr->name(), (uint64_t*)&(*buffers)[bid][0], &(*buffer_sizes)[bid])); + &(*buffer_sizes)[bid + 1]); + query->set_offsets_buffer( + attr->name(), (uint64_t*)&(*buffers)[bid][0], &(*buffer_sizes)[bid]); bid += 2; if (attr->nullable()) { - throw_if_not_ok(query->set_validity_buffer( - attr->name(), - (uint8_t*)&(*buffers)[bid][0], - &(*buffer_sizes)[bid])); + query->set_validity_buffer( + attr->name(), (uint8_t*)&(*buffers)[bid][0], &(*buffer_sizes)[bid]); ++bid; } } @@ -964,39 +961,39 @@ void FragmentConsolidator::set_query_buffers( auto dim{array_schema.dimension_ptr(d)}; auto dim_name = dim->name(); if (!dim->var_size()) { - throw_if_not_ok(query->set_data_buffer( - dim_name, (void*)&(*buffers)[bid][0], &(*buffer_sizes)[bid])); + query->set_data_buffer( + dim_name, (void*)&(*buffers)[bid][0], &(*buffer_sizes)[bid]); ++bid; } else { - throw_if_not_ok(query->set_data_buffer( + query->set_data_buffer( dim_name, (void*)&(*buffers)[bid + 1][0], - &(*buffer_sizes)[bid + 1])); - throw_if_not_ok(query->set_offsets_buffer( - dim_name, (uint64_t*)&(*buffers)[bid][0], &(*buffer_sizes)[bid])); + &(*buffer_sizes)[bid + 1]); + query->set_offsets_buffer( + dim_name, (uint64_t*)&(*buffers)[bid][0], &(*buffer_sizes)[bid]); bid += 2; } } } if (config_.with_timestamps_ && !dense) { - throw_if_not_ok(query->set_data_buffer( + query->set_data_buffer( constants::timestamps, (void*)&(*buffers)[bid][0], - &(*buffer_sizes)[bid])); + &(*buffer_sizes)[bid]); ++bid; } if (config_.with_delete_meta_ && !dense) { - throw_if_not_ok(query->set_data_buffer( + query->set_data_buffer( constants::delete_timestamps, (void*)&(*buffers)[bid][0], - &(*buffer_sizes)[bid])); + &(*buffer_sizes)[bid]); ++bid; - throw_if_not_ok(query->set_data_buffer( + query->set_data_buffer( constants::delete_condition_index, (void*)&(*buffers)[bid][0], - &(*buffer_sizes)[bid])); + &(*buffer_sizes)[bid]); ++bid; } } diff --git a/tiledb/sm/query/dimension_label/array_dimension_label_queries.cc b/tiledb/sm/query/dimension_label/array_dimension_label_queries.cc index b16436b870a..95b5d967c94 100644 --- a/tiledb/sm/query/dimension_label/array_dimension_label_queries.cc +++ b/tiledb/sm/query/dimension_label/array_dimension_label_queries.cc @@ -158,7 +158,7 @@ void ArrayDimensionLabelQueries::process_data_queries() { auto& query = data_queries_[query_idx]; try { query->init(); - throw_if_not_ok(query->process()); + query->process(); return Status::Ok(); } catch (const StatusException& err) { throw DimensionLabelQueryException( @@ -180,7 +180,7 @@ void ArrayDimensionLabelQueries::process_range_queries(Query* parent_query) { if (range_query) { // Process the query. range_query->init(); - throw_if_not_ok(range_query->process()); + range_query->process(); if (!range_query->completed()) { throw DimensionLabelQueryException( "Range query for label '" + range_query->dim_label_name() + diff --git a/tiledb/sm/query/dimension_label/dimension_label_query.cc b/tiledb/sm/query/dimension_label/dimension_label_query.cc index 6ce26c3cafd..369b78dd974 100644 --- a/tiledb/sm/query/dimension_label/dimension_label_query.cc +++ b/tiledb/sm/query/dimension_label/dimension_label_query.cc @@ -146,7 +146,7 @@ DimensionLabelQuery::DimensionLabelQuery( } // Set the basic query properies. - throw_if_not_ok(set_layout(Layout::ROW_MAJOR)); + set_layout(Layout::ROW_MAJOR); set_dimension_label_ordered_read( dim_label_ref.label_order() == DataOrder::INCREASING_DATA); @@ -156,11 +156,11 @@ DimensionLabelQuery::DimensionLabelQuery( set_subarray(subarray); // Set index data buffer that will store the computed ranges. - throw_if_not_ok(set_data_buffer( + set_data_buffer( array_schema().dimension_ptr(0)->name(), index_data_->data(), index_data_->data_size(), - true)); + true); } bool DimensionLabelQuery::completed() const { @@ -173,7 +173,7 @@ void DimensionLabelQuery::initialize_read_labels_query( const QueryBuffer& label_buffer, const uint32_t dim_idx) { // Set the layout (ordered, 1D). - throw_if_not_ok(set_layout(Layout::ROW_MAJOR)); + set_layout(Layout::ROW_MAJOR); // Set the subarray if it has index ranges added to it. if (!parent_subarray.is_default(dim_idx) && @@ -194,7 +194,7 @@ void DimensionLabelQuery::initialize_ordered_write_query( const QueryBuffer& index_buffer, const uint32_t dim_idx) { // Set query layout. - throw_if_not_ok(set_layout(Layout::ROW_MAJOR)); + set_layout(Layout::ROW_MAJOR); // Set the label data buffer. set_dimension_label_buffer(label_attr_name, label_buffer); @@ -255,14 +255,14 @@ void DimensionLabelQuery::initialize_unordered_write_query( } // Set-up indexed array query (sparse array). - throw_if_not_ok(set_layout(Layout::UNORDERED)); + set_layout(Layout::UNORDERED); set_dimension_label_buffer(label_attr_name, label_buffer); if (use_local_index) { - throw_if_not_ok(set_data_buffer( + set_data_buffer( array_schema().dimension_ptr(0)->name(), index_data_->data(), index_data_->data_size(), - true)); + true); } else { set_dimension_label_buffer( array_schema().dimension_ptr(0)->name(), index_buffer); diff --git a/tiledb/sm/query/query.cc b/tiledb/sm/query/query.cc index 5efb793d372..1bf0ae36641 100644 --- a/tiledb/sm/query/query.cc +++ b/tiledb/sm/query/query.cc @@ -297,49 +297,41 @@ Query::get_max_mem_size_map() { return subarray_.get_max_mem_size_map(&config_, &resources_.compute_tp()); } -Status Query::get_written_fragment_num(uint32_t* num) const { +uint32_t Query::get_written_fragment_num() const { if (type_ != QueryType::WRITE) { - return logger_->status(Status_QueryError( - "Cannot get number of fragments; Applicable only to WRITE mode")); + throw QueryException( + "Cannot get number of fragments; Applicable only to WRITE mode"); } - *num = (uint32_t)written_fragment_info_.size(); - - return Status::Ok(); + return (uint32_t)written_fragment_info_.size(); } -Status Query::get_written_fragment_uri(uint32_t idx, const char** uri) const { +const URI& Query::get_written_fragment_uri(uint32_t idx) const { if (type_ != QueryType::WRITE) { - return logger_->status(Status_QueryError( - "Cannot get fragment URI; Applicable only to WRITE mode")); + throw QueryException( + "Cannot get fragment URI; Applicable only to WRITE mode"); } auto num = (uint32_t)written_fragment_info_.size(); if (idx >= num) - return logger_->status( - Status_QueryError("Cannot get fragment URI; Invalid fragment index")); + throw QueryException("Cannot get fragment URI; Invalid fragment index"); - *uri = written_fragment_info_[idx].uri_.c_str(); - - return Status::Ok(); + return written_fragment_info_[idx].uri_; } -Status Query::get_written_fragment_timestamp_range( - uint32_t idx, uint64_t* t1, uint64_t* t2) const { +timestamp_range_type Query::get_written_fragment_timestamp_range( + uint32_t idx) const { if (type_ != QueryType::WRITE) { - return logger_->status(Status_QueryError( - "Cannot get fragment timestamp range; Applicable only to WRITE mode")); + throw QueryException( + "Cannot get fragment timestamp range; Applicable only to WRITE mode"); } auto num = (uint32_t)written_fragment_info_.size(); if (idx >= num) - return logger_->status(Status_QueryError( - "Cannot get fragment timestamp range; Invalid fragment index")); - - *t1 = written_fragment_info_[idx].timestamp_range_.first; - *t2 = written_fragment_info_[idx].timestamp_range_.second; + throw QueryException( + "Cannot get fragment timestamp range; Invalid fragment index"); - return Status::Ok(); + return written_fragment_info_[idx].timestamp_range_; } const Array* Query::array() const { @@ -442,10 +434,10 @@ QueryBuffer Query::buffer(const std::string& name) const { return QueryBuffer{}; } -Status Query::finalize() { +void Query::finalize() { if (status_ == QueryStatus::UNINITIALIZED || (status_ == QueryStatus::INITIALIZED && !array_->is_remote())) { - return Status::Ok(); + return; } if (array_->is_remote() && type_ == QueryType::WRITE) { @@ -460,16 +452,17 @@ Status Query::finalize() { "Failed to finalize query; remote global order writes are only " "allowed to call submit_and_finalize to submit the last tile"); } - return rest_client->finalize_query_to_rest(array_->array_uri(), this); + throw_if_not_ok( + rest_client->finalize_query_to_rest(array_->array_uri(), this)); + return; } throw_if_not_ok(strategy_->finalize()); status_ = QueryStatus::COMPLETED; - return Status::Ok(); } -Status Query::submit_and_finalize() { +void Query::submit_and_finalize() { if (type_ != QueryType::WRITE || layout_ != Layout::GLOBAL_ORDER) { throw QueryException( "Failed to submit and finalize query; Call valid only in global_order " @@ -477,7 +470,7 @@ Status Query::submit_and_finalize() { } // Check attribute/dimensions buffers completeness before query submits - throw_if_not_ok(check_buffers_correctness()); + check_buffers_correctness(); if (array_->is_remote()) { auto rest_client = resources_.rest_client(); @@ -488,76 +481,63 @@ Status Query::submit_and_finalize() { } if (status_ == QueryStatus::UNINITIALIZED) { - throw_if_not_ok(create_strategy()); + create_strategy(); } - return rest_client->submit_and_finalize_query_to_rest( - array_->array_uri(), this); + throw_if_not_ok(rest_client->submit_and_finalize_query_to_rest( + array_->array_uri(), this)); + return; } init(); - throw_if_not_ok(storage_manager_->query_submit(this)); + storage_manager_->query_submit(this); throw_if_not_ok(strategy_->finalize()); status_ = QueryStatus::COMPLETED; - - return Status::Ok(); } -Status Query::get_offsets_buffer( - const char* name, uint64_t** buffer_off, uint64_t** buffer_off_size) const { +query_buffer_t Query::get_offsets_buffer(const char* name) const { // Check query type if (type_ != QueryType::READ && type_ != QueryType::WRITE) { - return LOG_STATUS(Status_SerializationError( - "Cannot get buffer; Unsupported query type.")); + throw QueryException("Cannot get buffer; Unsupported query type."); } // Check attribute if (name == constants::coords) { - return logger_->status( - Status_QueryError("Cannot get buffer; Coordinates are not var-sized")); + throw QueryException("Cannot get buffer; Coordinates are not var-sized"); } if (array_schema_->attribute(name) == nullptr && array_schema_->dimension_ptr(name) == nullptr && !array_schema_->is_dim_label(name)) { - return logger_->status(Status_QueryError( + throw QueryException( std::string( "Cannot get buffer; Invalid attribute/dimension/label name '") + - name + "'")); + name + "'"); } if (!array_schema_->var_size(name)) { - return logger_->status(Status_QueryError( - std::string("Cannot get buffer; '") + name + "' is fixed-sized")); + throw QueryException( + std::string("Cannot get buffer; '") + name + "' is fixed-sized"); } // Attribute or dimension auto it = buffers_.find(name); if (it != buffers_.end()) { - *buffer_off = (uint64_t*)it->second.buffer_; - *buffer_off_size = it->second.buffer_size_; - return Status::Ok(); + return it->second.get_offsets_buffer(); } // Dimension label it = label_buffers_.find(name); if (it != label_buffers_.end()) { - *buffer_off = (uint64_t*)it->second.buffer_; - *buffer_off_size = it->second.buffer_size_; - return Status::Ok(); + return it->second.get_offsets_buffer(); } // Named buffer does not exist - *buffer_off = nullptr; - *buffer_off_size = nullptr; - - return Status::Ok(); + return {nullptr, nullptr}; } -Status Query::get_data_buffer( - const char* name, void** buffer, uint64_t** buffer_size) const { +query_buffer_t Query::get_data_buffer(const char* name) const { // Check query type if (type_ != QueryType::READ && type_ != QueryType::WRITE) { - return LOG_STATUS(Status_SerializationError( - "Cannot get buffer; Unsupported query type.")); + throw QueryException("Cannot get buffer; Unsupported query type."); } // Check attribute @@ -565,76 +545,51 @@ Status Query::get_data_buffer( if (array_schema_->attribute(name) == nullptr && array_schema_->dimension_ptr(name) == nullptr && !array_schema_->is_dim_label(name)) - return logger_->status(Status_QueryError( + throw QueryException( std::string( "Cannot get buffer; Invalid attribute/dimension/label name '") + - name + "'")); + name + "'"); } // Special zipped coordinates if ((type_ == QueryType::WRITE) && name == constants::coords) { - *buffer = coords_info_.coords_buffer_; - *buffer_size = coords_info_.coords_buffer_size_; - return Status::Ok(); + return {coords_info_.coords_buffer_, coords_info_.coords_buffer_size_}; } - // Attribute or dimension + bool is_var = false; auto it = buffers_.find(name); if (it != buffers_.end()) { - if (!array_schema_->var_size(name)) { - *buffer = it->second.buffer_; - *buffer_size = it->second.buffer_size_; - } else { - *buffer = it->second.buffer_var_; - *buffer_size = it->second.buffer_var_size_; - } - return Status::Ok(); - } - - // Return the buffer - it = label_buffers_.find(name); - if (it != label_buffers_.end()) { - if (array_schema_->dimension_label(name).is_var()) { - *buffer = it->second.buffer_var_; - *buffer_size = it->second.buffer_var_size_; - } else { - *buffer = it->second.buffer_; - *buffer_size = it->second.buffer_size_; - } - return Status::Ok(); + // Attribute or dimension + is_var = array_schema_->var_size(name); + } else if (it = label_buffers_.find(name); it != label_buffers_.end()) { + // Dimension label + is_var = array_schema_->dimension_label(name).is_var(); + } else { + // Named buffer does not exist + return {nullptr, nullptr}; } - // Named buffer does not exist - *buffer = nullptr; - *buffer_size = nullptr; - - return Status::Ok(); + return it->second.get_data_buffer(is_var); } -Status Query::get_validity_buffer( - const char* name, - uint8_t** buffer_validity_bytemap, - uint64_t** buffer_validity_bytemap_size) const { +query_buffer_t Query::get_validity_buffer(const char* name) const { // Check query type if (type_ != QueryType::READ && type_ != QueryType::WRITE) { - return LOG_STATUS(Status_SerializationError( - "Cannot get buffer; Unsupported query type.")); + throw QueryException("Cannot get buffer; Unsupported query type."); } // Check attribute if (!array_schema_->is_nullable(name)) - return logger_->status(Status_QueryError( - std::string("Cannot get buffer; '") + name + "' is non-nullable")); + throw QueryException( + std::string("Cannot get buffer; '") + name + "' is non-nullable"); // Attribute or dimension auto it = buffers_.find(name); if (it != buffers_.end()) { - auto vv = &it->second.validity_vector_; - *buffer_validity_bytemap = vv->bytemap(); - *buffer_validity_bytemap_size = vv->bytemap_size(); + return it->second.get_validity_buffer(); } - return Status::Ok(); + return {nullptr, nullptr}; } Status Query::get_attr_serialization_state( @@ -676,7 +631,7 @@ void Query::init() { ")"); } - throw_if_not_ok(check_buffer_names()); + check_buffer_names(); // Create dimension label queries and remove labels from subarray. if (uses_dimension_labels()) { @@ -720,7 +675,7 @@ void Query::init() { // Create the query strategy if querying main array and the Subarray does // not need to be updated. if (!only_dim_label_query() && !subarray_.has_label_ranges()) { - throw_if_not_ok(create_strategy()); + create_strategy(); } } @@ -769,11 +724,10 @@ bool Query::cancelled() { return local_state_machine_.is_cancelled(); } -Status Query::process() { +void Query::process() { if (status_ == QueryStatus::UNINITIALIZED || status_ == QueryStatus::INITIALIZED) { - return logger_->status( - Status_QueryError("Cannot process query; Query is not initialized")); + throw QueryException("Cannot process query; Query is not initialized"); } status_ = QueryStatus::INPROGRESS; @@ -790,9 +744,9 @@ Status Query::process() { // dimension label queries. if (!dim_label_queries_->completed_range_queries()) { status_ = QueryStatus::FAILED; - return logger_->status( - Status_QueryError("Cannot process query; Failed to read data from " - "dimension label ranges.")); + throw QueryException( + "Cannot process query; Failed to read data from " + "dimension label ranges."); } if (!only_dim_label_query()) { @@ -803,7 +757,7 @@ Status Query::process() { } // This changes the query into INITIALIZED, but it's ok as the status // is updated correctly below - throw_if_not_ok(create_strategy()); + create_strategy(); } } @@ -915,7 +869,7 @@ Status Query::process() { // Handle error if (!st.ok()) { status_ = QueryStatus::FAILED; - return st; + throw_if_not_ok(st); } // Check if the query is completed or not. @@ -933,18 +887,16 @@ Status Query::process() { // Either the main query or the dimension lable query are incomplete. status_ = QueryStatus::INCOMPLETE; } - - return Status::Ok(); } IQueryStrategy* Query::strategy(bool skip_checks_serialization) { if (strategy_ == nullptr) { - throw_if_not_ok(create_strategy(skip_checks_serialization)); + create_strategy(skip_checks_serialization); } return strategy_.get(); } -Status Query::reset_strategy_with_layout( +void Query::reset_strategy_with_layout( Layout layout, bool force_legacy_reader) { force_legacy_reader_ = force_legacy_reader; if (strategy_ != nullptr) { @@ -954,9 +906,7 @@ Status Query::reset_strategy_with_layout( } layout_ = layout; subarray_.set_layout(layout); - RETURN_NOT_OK(create_strategy(true)); - - return Status::Ok(); + create_strategy(true); } bool Query::uses_dimension_labels() const { @@ -964,36 +914,34 @@ bool Query::uses_dimension_labels() const { dim_label_queries_; } -Status Query::disable_checks_consolidation() { +void Query::disable_checks_consolidation() { if (status_ != QueryStatus::UNINITIALIZED) { - return logger_->status(Status_QueryError( - "Cannot disable checks for consolidation after initialization")); + throw QueryException( + "Cannot disable checks for consolidation after initialization"); } if (type_ != QueryType::WRITE) { - return logger_->status( - Status_QueryError("Cannot disable checks for consolidation; Applicable " - "only to write mode")); + throw QueryException( + "Cannot disable checks for consolidation; Applicable " + "only to write mode"); } disable_checks_consolidation_ = true; - return Status::Ok(); } -Status Query::set_consolidation_with_timestamps() { +void Query::set_consolidation_with_timestamps() { if (status_ != QueryStatus::UNINITIALIZED) { - return logger_->status(Status_QueryError( - "Cannot enable consolidation with timestamps after initialization")); + throw QueryException( + "Cannot enable consolidation with timestamps after initialization"); } if (type_ != QueryType::READ) { - return logger_->status(Status_QueryError( + throw QueryException( "Cannot enable consolidation with timestamps; Applicable only to " - "reads")); + "reads"); } consolidation_with_timestamps_ = true; - return Status::Ok(); } void Query::set_processed_conditions( @@ -1022,50 +970,46 @@ void Query::set_config(const Config& config) { subarray_.set_config(type_, config_); } -Status Query::set_coords_buffer(void* buffer, uint64_t* buffer_size) { +void Query::set_coords_buffer(void* buffer, uint64_t* buffer_size) { // Set zipped coordinates buffer coords_info_.coords_buffer_ = buffer; coords_info_.coords_buffer_size_ = buffer_size; coords_info_.has_coords_ = true; - - return Status::Ok(); } void Query::set_dimension_label_buffer( const std::string& name, const QueryBuffer& buffer) { if (buffer.buffer_var_ || buffer.buffer_var_size_) { // Variable-length buffer. Set data buffer and offsets buffer. - throw_if_not_ok( - set_data_buffer(name, buffer.buffer_var_, buffer.buffer_var_size_)); - throw_if_not_ok(set_offsets_buffer( - name, static_cast(buffer.buffer_), buffer.buffer_size_)); + + set_data_buffer(name, buffer.buffer_var_, buffer.buffer_var_size_); + set_offsets_buffer( + name, static_cast(buffer.buffer_), buffer.buffer_size_); } else { // Fixed-length buffer. Set data buffer only. - throw_if_not_ok(set_data_buffer(name, buffer.buffer_, buffer.buffer_size_)); + set_data_buffer(name, buffer.buffer_, buffer.buffer_size_); } } -Status Query::set_data_buffer( +void Query::set_data_buffer( const std::string& name, void* const buffer, uint64_t* const buffer_size, const bool check_null_buffers, const bool serialization_allow_new_attr) { // General checks for fixed buffers - RETURN_NOT_OK(check_set_fixed_buffer(name)); + check_set_fixed_buffer(name); // Check buffer if (check_null_buffers && buffer == nullptr) { if (type_ != QueryType::WRITE || *buffer_size != 0) { - return logger_->status( - Status_QueryError("Cannot set buffer; " + name + " buffer is null")); + throw QueryException("Cannot set buffer; " + name + " buffer is null"); } } // Check buffer size if (check_null_buffers && buffer_size == nullptr) { - return logger_->status(Status_QueryError( - "Cannot set buffer; " + name + " buffer size is null")); + throw QueryException("Cannot set buffer; " + name + " buffer size is null"); } // If this is for a dimension label, set the dimension label buffer and @@ -1089,7 +1033,7 @@ Status Query::set_data_buffer( array_schema_->dimension_label(name).is_var() ? label_buffers_[name].set_data_var_buffer(buffer, buffer_size) : label_buffers_[name].set_data_buffer(buffer, buffer_size); - return Status::Ok(); + return; } // If this is an aggregate buffer, set it and return. @@ -1104,7 +1048,7 @@ Status Query::set_data_buffer( aggregate_buffers_[name].set_data_var_buffer(buffer, buffer_size); } - return Status::Ok(); + return; } // For easy reference @@ -1113,31 +1057,31 @@ Status Query::set_data_buffer( // Check that attribute/dimension exists if (!ArraySchema::is_special_attribute(name) && !is_dim && !is_attr) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer; Invalid attribute/dimension/label '") + - name + "'")); + name + "'"); } if (array_schema_->dense() && type_ == QueryType::WRITE && !is_attr) { - return logger_->status(Status_QueryError( - std::string("Dense write queries cannot set dimension buffers"))); + throw QueryException( + std::string("Dense write queries cannot set dimension buffers")); } // Check if zipped coordinates coexist with separate coordinate buffers if ((is_dim && has_zipped_coords_buffer_) || (name == constants::coords && has_coords_buffer_)) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set separate coordinate buffers and " - "a zipped coordinate buffer in the same query"))); + "a zipped coordinate buffer in the same query")); } // Error if setting a new attribute/dimension after initialization const bool exists = buffers_.find(name) != buffers_.end(); if (status_ != QueryStatus::UNINITIALIZED && !exists && !allow_separate_attribute_writes() && !serialization_allow_new_attr) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer for new attribute/dimension '") + name + - "' after initialization")); + "' after initialization"); } if (name == constants::coords) { @@ -1154,11 +1098,11 @@ Status Query::set_data_buffer( uint64_t coords_num = *buffer_size / array_schema_->cell_size(name); if (coord_data_buffer_is_set_ && coords_num != coords_info_.coords_num_ && name == data_buffer_name_) - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer; Input buffer for dimension '") + name + "' has a different number of coordinates than previously " - "set coordinate buffers")); + "set coordinate buffers"); coords_info_.coords_num_ = coords_num; coord_data_buffer_is_set_ = true; @@ -1168,8 +1112,8 @@ Status Query::set_data_buffer( // Make sure the buffer was not already written. if (written_buffers_.count(name) != 0) { - return logger_->status(Status_QueryError( - std::string("Buffer ") + name + std::string(" was already written"))); + throw QueryException( + std::string("Buffer ") + name + std::string(" was already written")); } has_coords_buffer_ |= is_dim; @@ -1182,8 +1126,6 @@ Status Query::set_data_buffer( // Var sized data buffer buffers_[name].set_data_var_buffer(buffer, buffer_size); } - - return Status::Ok(); } std::optional> Query::get_aggregate( @@ -1195,24 +1137,22 @@ std::optional> Query::get_aggregate( return it->second; } -Status Query::set_offsets_buffer( +void Query::set_offsets_buffer( const std::string& name, uint64_t* const buffer_offsets, uint64_t* const buffer_offsets_size, const bool check_null_buffers, const bool serialization_allow_new_attr) { - RETURN_NOT_OK(check_set_fixed_buffer(name)); + check_set_fixed_buffer(name); // Check buffer if (check_null_buffers && buffer_offsets == nullptr) { - return logger_->status( - Status_QueryError("Cannot set buffer; " + name + " buffer is null")); + throw QueryException("Cannot set buffer; " + name + " buffer is null"); } // Check buffer size if (check_null_buffers && buffer_offsets_size == nullptr) { - return logger_->status(Status_QueryError( - "Cannot set buffer; " + name + " buffer size is null")); + throw QueryException("Cannot set buffer; " + name + " buffer size is null"); } // If this is for a dimension label, set the dimension label offsets buffer @@ -1242,22 +1182,22 @@ Status Query::set_offsets_buffer( // Set dimension label offsets buffers. label_buffers_[name].set_offsets_buffer( buffer_offsets, buffer_offsets_size); - return Status::Ok(); + return; } // If this is an aggregate buffer, set it and return. if (is_aggregate(name)) { if (!array_schema_->var_size( default_channel_aggregates_[name]->field_name())) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer; Input attribute '") + name + - "' is not var sized")); + "' is not var sized"); } aggregate_buffers_[name].set_offsets_buffer( buffer_offsets, buffer_offsets_size); - return Status::Ok(); + return; } // For easy reference @@ -1266,25 +1206,25 @@ Status Query::set_offsets_buffer( // Neither a dimension nor an attribute if (!is_dim && !is_attr) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer; Invalid buffer name '") + name + - "' (it should be an attribute, dimension, or dimension label)")); + "' (it should be an attribute, dimension, or dimension label)"); } // Error if it is fixed-sized if (!array_schema_->var_size(name)) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer; Input attribute/dimension '") + name + - "' is fixed-sized")); + "' is fixed-sized"); } // Error if setting a new attribute/dimension after initialization const bool exists = buffers_.find(name) != buffers_.end(); if (status_ != QueryStatus::UNINITIALIZED && !exists && !allow_separate_attribute_writes() && !serialization_allow_new_attr) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer for new attribute/dimension '") + name + - "' after initialization")); + "' after initialization"); } if (is_dim && type_ == QueryType::WRITE) { @@ -1304,11 +1244,11 @@ Status Query::set_offsets_buffer( if (coord_offsets_buffer_is_set_ && coords_num != coords_info_.coords_num_ && name == offsets_buffer_name_) - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer; Input buffer for dimension '") + name + "' has a different number of coordinates than previously " - "set coordinate buffers")); + "set coordinate buffers"); coords_info_.coords_num_ = coords_num; coord_offsets_buffer_is_set_ = true; @@ -1318,108 +1258,102 @@ Status Query::set_offsets_buffer( // Make sure the buffer was not already written. if (written_buffers_.count(name) != 0) { - return logger_->status(Status_QueryError( - std::string("Buffer ") + name + std::string(" was already written"))); + throw QueryException( + std::string("Buffer ") + name + std::string(" was already written")); } has_coords_buffer_ |= is_dim; // Set attribute/dimension buffer buffers_[name].set_offsets_buffer(buffer_offsets, buffer_offsets_size); - - return Status::Ok(); } -Status Query::set_validity_buffer( +void Query::set_validity_buffer( const std::string& name, uint8_t* const buffer_validity_bytemap, uint64_t* const buffer_validity_bytemap_size, const bool check_null_buffers, const bool serialization_allow_new_attr) { - RETURN_NOT_OK(check_set_fixed_buffer(name)); + check_set_fixed_buffer(name); // Check validity buffer if (check_null_buffers && buffer_validity_bytemap == nullptr) { - return logger_->status(Status_QueryError( - "Cannot set buffer; " + name + " validity buffer is null")); + throw QueryException( + "Cannot set buffer; " + name + " validity buffer is null"); } // Check validity buffer size if (check_null_buffers && buffer_validity_bytemap_size == nullptr) { - return logger_->status(Status_QueryError( - "Cannot set buffer; " + name + " validity buffer size is null")); + throw QueryException( + "Cannot set buffer; " + name + " validity buffer size is null"); } // If this is an aggregate buffer, set it and return. if (is_aggregate(name)) { if (!array_schema_->is_nullable( default_channel_aggregates_[name]->field_name())) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer; Input attribute '") + name + - "' is not nullable")); + "' is not nullable"); } aggregate_buffers_[name].set_validity_buffer( {buffer_validity_bytemap, buffer_validity_bytemap_size}); - return Status::Ok(); + return; } // Must be an attribute if (!array_schema_->is_attr(name)) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer; Buffer name '") + name + - "' is not an attribute")); + "' is not an attribute"); } // Must be nullable if (!array_schema_->is_nullable(name)) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer; Input attribute '") + name + - "' is not nullable")); + "' is not nullable"); } // Error if setting a new attribute after initialization const bool exists = buffers_.find(name) != buffers_.end(); if (status_ != QueryStatus::UNINITIALIZED && !exists && !allow_separate_attribute_writes() && !serialization_allow_new_attr) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Cannot set buffer for new attribute '") + name + - "' after initialization")); + "' after initialization"); } // Make sure the buffer was not already written. if (written_buffers_.count(name) != 0) { - return logger_->status(Status_QueryError( - std::string("Buffer ") + name + std::string(" was already written"))); + throw QueryException( + std::string("Buffer ") + name + std::string(" was already written")); } // Set attribute/dimension buffer buffers_[name].set_validity_buffer( {buffer_validity_bytemap, buffer_validity_bytemap_size}); - - return Status::Ok(); } -Status Query::set_est_result_size( +void Query::set_est_result_size( std::unordered_map& est_result_size, std::unordered_map& max_mem_size) { if (type_ != QueryType::READ) { - return LOG_STATUS(Status_SerializationError( - "Cannot set estimated result size; Unsupported query type.")); + throw QueryException( + "Cannot set estimated result size; Unsupported query type."); } subarray_.set_est_result_size(est_result_size, max_mem_size); - return Status::Ok(); } -Status Query::set_layout(Layout layout) { +void Query::set_layout(Layout layout) { if (layout == layout_) { // Noop - return Status::Ok(); + return; } if (status_ != QueryStatus::UNINITIALIZED) { - return logger_->status( - Status_QueryError("Cannot set layout after initialization")); + throw QueryException("Cannot set layout after initialization"); } switch (type_) { @@ -1430,45 +1364,43 @@ Status Query::set_layout(Layout layout) { if (array_schema_->dense()) { // Check layout for dense writes is valid. if (layout == Layout::UNORDERED) { - return logger_->status(Status_QueryError( - "Unordered writes are only possible for sparse arrays")); + throw QueryException( + "Unordered writes are only possible for sparse arrays"); } } else { // Check layout for sparse writes is valid. if (layout == Layout::ROW_MAJOR || layout == Layout::COL_MAJOR) { - return logger_->status( - Status_QueryError("Row-major and column-major writes are only " - "possible for dense arrays")); + throw QueryException( + "Row-major and column-major writes are only " + "possible for dense arrays"); } } break; default: - return LOG_STATUS(Status_SerializationError( - "Cannot set layout; Unsupported query type.")); + throw QueryException("Cannot set layout; Unsupported query type."); } if (layout == Layout::HILBERT) { - return logger_->status(Status_QueryError( - "Cannot set layout; Hilbert order is not applicable to queries")); + throw QueryException( + "Cannot set layout; Hilbert order is not applicable to queries"); } layout_ = layout; subarray_.set_layout(layout); - return Status::Ok(); } -Status Query::set_condition(const QueryCondition& condition) { +void Query::set_condition(const QueryCondition& condition) { if (type_ == QueryType::WRITE) { - return logger_->status(Status_QueryError( + throw QueryException( "Cannot set query condition; Operation not applicable " - "to write queries")); + "to write queries"); } if (status_ != tiledb::sm::QueryStatus::UNINITIALIZED) { - return logger_->status(Status_QueryError( + throw QueryException( "Cannot set query condition; Setting a query condition on an already" - "initialized query is not supported.")); + "initialized query is not supported."); } if (condition.empty()) { @@ -1476,34 +1408,30 @@ Status Query::set_condition(const QueryCondition& condition) { } condition_ = condition; - - return Status::Ok(); } -Status Query::add_update_value( +void Query::add_update_value( const char* field_name, const void* update_value, uint64_t update_value_size) { if (type_ != QueryType::UPDATE) { - return logger_->status(Status_QueryError( + throw QueryException( "Cannot add query update value; Operation only applicable " - "to update queries")); + "to update queries"); } // Make sure the array is sparse. if (array_schema_->dense()) { - return logger_->status(Status_QueryError( - "Setting update values is only valid for sparse arrays")); + throw QueryException( + "Setting update values is only valid for sparse arrays"); } if (attributes_with_update_value_.count(field_name) != 0) { - return logger_->status( - Status_QueryError("Update value already set for attribute")); + throw QueryException("Update value already set for attribute"); } attributes_with_update_value_.emplace(field_name); update_values_.emplace_back(field_name, update_value, update_value_size); - return Status::Ok(); } void Query::add_index_ranges_from_label( @@ -1555,9 +1483,8 @@ const Subarray* Query::subarray() const { return &subarray_; } -Status Query::set_subarray_unsafe(const Subarray& subarray) { +void Query::set_subarray_unsafe(const Subarray& subarray) { subarray_ = subarray; - return Status::Ok(); } void Query::set_subarray(const tiledb::sm::Subarray& subarray) { @@ -1594,7 +1521,7 @@ void Query::set_subarray(const tiledb::sm::Subarray& subarray) { subarray_.set_layout(prev_layout); } -Status Query::set_subarray_unsafe(const NDRange& subarray) { +void Query::set_subarray_unsafe(const NDRange& subarray) { // Prepare a subarray object Subarray sub(array_, layout_, stats_, logger_); if (!subarray.empty()) { @@ -1605,18 +1532,16 @@ Status Query::set_subarray_unsafe(const NDRange& subarray) { passert(layout_ == sub.layout()); subarray_ = sub; - - return Status::Ok(); } void Query::set_subarray_unsafe(const void* subarray) { subarray_.set_subarray_unsafe(subarray); } -Status Query::submit() { +void Query::submit() { // Do not resubmit completed reads. if (type_ == QueryType::READ && status_ == QueryStatus::COMPLETED) { - return Status::Ok(); + return; } // Make sure fragment size is only set for global order. @@ -1636,7 +1561,7 @@ Status Query::submit() { } // Check attribute/dimensions buffers completeness before query submits - throw_if_not_ok(check_buffers_correctness()); + check_buffers_correctness(); if (array_->is_remote()) { auto rest_client = resources_.rest_client(); @@ -1647,7 +1572,7 @@ Status Query::submit() { if (status_ == QueryStatus::UNINITIALIZED && !only_dim_label_query() && !subarray_.has_label_ranges()) { - throw_if_not_ok(create_strategy()); + create_strategy(); // Allocate remote buffer storage for global order writes if necessary. // If we cache an entire write a query may be uninitialized for N submits. @@ -1661,13 +1586,12 @@ Status Query::submit() { rest_client->submit_query_to_rest(array_->array_uri(), this)); reset_coords_markers(); - return Status::Ok(); + return; } init(); - throw_if_not_ok(storage_manager_->query_submit(this)); + storage_manager_->query_submit(this); reset_coords_markers(); - return Status::Ok(); } QueryStatus Query::status() const { @@ -1796,7 +1720,7 @@ Layout Query::effective_layout() const { return layout_; } -Status Query::create_strategy(bool skip_checks_serialization) { +void Query::create_strategy(bool skip_checks_serialization) { auto layout = effective_layout(); auto params = StrategyParams( resources_, @@ -1817,7 +1741,7 @@ Status Query::create_strategy(bool skip_checks_serialization) { if (type_ == QueryType::WRITE) { if (layout == Layout::COL_MAJOR || layout == Layout::ROW_MAJOR) { if (!array_schema_->dense()) { - return Status_QueryError( + throw QueryException( "Cannot create strategy; sparse writes do not support layout " + layout_str(layout)); } @@ -1832,7 +1756,7 @@ Status Query::create_strategy(bool skip_checks_serialization) { fragment_name_)); } else if (layout == Layout::UNORDERED) { if (array_schema_->dense()) { - return Status_QueryError( + throw QueryException( "Cannot create strategy; dense writes do not support layout " + layout_str(layout)); } @@ -1860,7 +1784,7 @@ Status Query::create_strategy(bool skip_checks_serialization) { remote_query_, fragment_name_)); } else { - return Status_QueryError( + throw QueryException( "Cannot create strategy; unsupported layout " + layout_str(layout)); } } else if (type_ == QueryType::READ) { @@ -1948,56 +1872,49 @@ Status Query::create_strategy(bool skip_checks_serialization) { params, update_values_)); } else { - return logger_->status( - Status_QueryError("Cannot create strategy; unsupported query type")); + throw QueryException("Cannot create strategy; unsupported query type"); } if (strategy_ == nullptr) - return logger_->status( - Status_QueryError("Cannot create strategy; allocation failed")); + throw QueryException("Cannot create strategy; allocation failed"); // Transition the query into INITIALIZED state if (!skip_checks_serialization) { set_status(QueryStatus::INITIALIZED); } - - return Status::Ok(); } -Status Query::check_set_fixed_buffer(const std::string& name) { +void Query::check_set_fixed_buffer(const std::string& name) { if (type_ != QueryType::READ && type_ != QueryType::WRITE) { - return LOG_STATUS(Status_SerializationError( - "Cannot set buffer; Unsupported query type.")); + throw QueryException("Cannot set buffer; Unsupported query type."); } if (name == constants::coords && !array_schema_->domain().all_dims_same_type()) - return logger_->status(Status_QueryError( + throw QueryException( "Cannot set buffer; Setting a buffer for zipped coordinates is not " - "applicable to heterogeneous domains")); + "applicable to heterogeneous domains"); if (name == constants::coords && !array_schema_->domain().all_dims_fixed()) - return logger_->status(Status_QueryError( + throw QueryException( "Cannot set buffer; Setting a buffer for zipped coordinates is not " - "applicable to domains with variable-sized dimensions")); - - return Status::Ok(); + "applicable to domains with variable-sized dimensions"); } -Status Query::check_buffer_names() { +void Query::check_buffer_names() { if (type_ == QueryType::WRITE) { // If the array is sparse, the coordinates must be provided if (!array_schema_->dense() && !coords_info_.has_coords_) { - return logger_->status( - Status_QueryError("Sparse array writes expect the coordinates of the " - "cells to be written")); + throw QueryException( + "Sparse array writes expect the coordinates of the " + "cells to be written"); } // If the layout is unordered, the coordinates must be provided if (layout_ == Layout::UNORDERED && !coords_info_.has_coords_) { - return logger_->status( - Status_QueryError("Unordered writes expect the coordinates of the " - "cells to be written")); + throw QueryException( + "Unordered writes expect the coordinates of the " + "cells to be written"); } // All attributes/dimensions must be provided unless this query is only for @@ -2015,9 +1932,9 @@ Status Query::check_buffer_names() { array_schema_->dim_num() : 0; if (buffers_.size() != expected_num) { - return logger_->status(Status_QueryError( + throw QueryException( "Writes expect all attributes (and coordinates in " - "the sparse/unordered case) to be set")); + "the sparse/unordered case) to be set"); } } @@ -2033,11 +1950,9 @@ Status Query::check_buffer_names() { } } } - - return Status::Ok(); } -Status Query::check_buffers_correctness() { +void Query::check_buffers_correctness() { ensure_query_type_is_valid(type_); // Iterate through each attribute @@ -2047,43 +1962,42 @@ Status Query::check_buffers_correctness() { // buffer if (type_ == QueryType::READ) { if (buffer(attr).buffer_var_ == nullptr) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Var-Sized input attribute/dimension '") + attr + - "' is not set correctly. \nVar size buffer is not set.")); + "' is not set correctly. \nVar size buffer is not set."); } } else { if (buffer(attr).buffer_var_ == nullptr && *buffer(attr).buffer_var_size_ != 0) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Var-Sized input attribute/dimension '") + attr + "' is not set correctly. \nVar size buffer is not set and " "buffer " - "size if not 0.")); + "size if not 0."); } } if (buffer(attr).buffer_ == nullptr) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Var-Sized input attribute/dimension '") + attr + - "' is not set correctly. \nOffsets buffer is not set.")); + "' is not set correctly. \nOffsets buffer is not set."); } } else { // Fixed sized if (buffer(attr).buffer_ == nullptr) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Fix-Sized input attribute/dimension '") + attr + - "' is not set correctly. \nData buffer is not set.")); + "' is not set correctly. \nData buffer is not set."); } } if (array_schema_->is_nullable(attr)) { bool exists_validity = buffer(attr).validity_vector_.buffer() != nullptr; if (!exists_validity) { - return logger_->status(Status_QueryError( + throw QueryException( std::string("Nullable input attribute/dimension '") + attr + - "' is not set correctly \nValidity buffer is not set")); + "' is not set correctly \nValidity buffer is not set"); } } } - return Status::Ok(); } bool Query::only_dim_label_query() const { @@ -2099,11 +2013,11 @@ bool Query::only_dim_label_query() const { coord_offsets_buffer_is_set_)))); } -Status Query::check_tile_alignment() const { +void Query::check_tile_alignment() const { // Only applicable for remote global order writes if (!array_->is_remote() || type_ != QueryType::WRITE || layout_ != Layout::GLOBAL_ORDER) { - return Status::Ok(); + return; } // It is enough to check for the first attr/dim only as we have @@ -2131,12 +2045,10 @@ Status Query::check_tile_alignment() const { } if (!buffers_tile_aligned) { - return Status_WriterError( + throw QueryException( "Tile alignment check failed; Input buffers need to be tile-aligned " "for remote global order writes."); } - - return Status::Ok(); } void Query::reset_coords_markers() { diff --git a/tiledb/sm/query/query.h b/tiledb/sm/query/query.h index c33d32bd559..2b04851adcf 100644 --- a/tiledb/sm/query/query.h +++ b/tiledb/sm/query/query.h @@ -44,6 +44,7 @@ #include "tiledb/sm/array_schema/dimension.h" #include "tiledb/sm/array_schema/domain.h" #include "tiledb/sm/enums/query_status_details.h" +#include "tiledb/sm/fragment/fragment_identifier.h" #include "tiledb/sm/fragment/written_fragment_info.h" #include "tiledb/sm/query/iquery_strategy.h" #include "tiledb/sm/query/query_buffer.h" @@ -270,17 +271,16 @@ class Query { public: /** Retrieves the number of written fragments. */ - Status get_written_fragment_num(uint32_t* num) const; + uint32_t get_written_fragment_num() const; /** Retrieves the URI of the written fragment with the input index. */ - Status get_written_fragment_uri(uint32_t idx, const char** uri) const; + const URI& get_written_fragment_uri(uint32_t idx) const; /** * Retrieves the timestamp range [t1,t2] of the written fragment with the * input index. */ - Status get_written_fragment_timestamp_range( - uint32_t idx, uint64_t* t1, uint64_t* t2) const; + timestamp_range_type get_written_fragment_timestamp_range(uint32_t idx) const; /** Returns the array's smart pointer. */ inline shared_ptr array_shared() { @@ -337,60 +337,48 @@ class Query { * Finalizes the query, flushing all internal state. * Applicable to write queries only. */ - Status finalize(); + void finalize(); /** * Submits and finalizes a query, flushing all internal state. Applicable * only to global layout writes, returns an error otherwise. */ - Status submit_and_finalize(); + void submit_and_finalize(); /** * Retrieves the data buffer of a fixed/var-sized attribute/dimension. * * @param name The buffer attribute/dimension name. An empty string means * the special default attribute/dimension. - * @param buffer The buffer to be retrieved. - * @param buffer_size A pointer to the buffer size to be retrieved. - * @return Status + * @return A pair of the pointers to the data, and to the size value. */ - Status get_data_buffer( - const char* name, void** buffer, uint64_t** buffer_size) const; + query_buffer_t get_data_buffer(const char* name) const; /** * Retrieves the offset buffer for a var-sized attribute/dimension. * * @param name The buffer attribute/dimension name. An empty string means * the special default attribute/dimension. - * @param buffer_off The offsets buffer to be retrieved. This buffer holds - * the starting offsets of each cell value in the data buffer. - * @param buffer_off_size A pointer to the buffer size to be retrieved. - * @return Status + * @return A pair of the pointers to the offsets, and to the size value. This + * buffer holds the starting offsets of each cell value in the data buffer. */ - Status get_offsets_buffer( - const char* name, - uint64_t** buffer_off, - uint64_t** buffer_off_size) const; + query_buffer_t get_offsets_buffer(const char* name) const; /** * Retrieves the validity buffer for a nullable attribute/dimension. * * @param name The buffer attribute/dimension name. An empty string means * the special default attribute/dimension. - * @param buffer_validity_bytemap The buffer that either have the validity - * bytemap associated with the input data to be written, or will hold the - * validity bytemap to be read. - * @param buffer_validity_bytemap_size In the case of writes, this is the size - * of `buffer_validity_bytemap` in bytes. In the case of reads, this initially - * contains the allocated size of `buffer_validity_bytemap`, but after the + * @return A pair of the pointers to the validity buffer, and to the size + * value. The buffer will either have the validity bytemap associated with the + * input data to be written, or will hold the validity bytemap to be read. The + * size pointer, in the case of writes, will contain the size of + * `buffer_validity_bytemap` in bytes, and in the case of reads, it will + * contain the allocated size of `buffer_validity_bytemap`, but after the * termination of the query it will contain the size of the useful (read) * data in `buffer_validity_bytemap`. - * @return Status */ - Status get_validity_buffer( - const char* name, - uint8_t** buffer_validity_bytemap, - uint64_t** buffer_validity_bytemap_size) const; + query_buffer_t get_validity_buffer(const char* name) const; /** * Returns the serialization state associated with the given attribute. @@ -460,7 +448,7 @@ class Query { bool uses_dimension_labels() const; /** Processes a query. */ - Status process(); + void process(); /** Gets the strategy of the query. */ IQueryStrategy* strategy(bool skip_checks_serialization = false); @@ -473,18 +461,18 @@ class Query { * requested it. * @return Status */ - Status reset_strategy_with_layout(Layout layout, bool force_legacy_reader); + void reset_strategy_with_layout(Layout layout, bool force_legacy_reader); /** * Disables checking the global order and coordinate duplicates. Applicable * only to writes. This option will supercede the config. */ - Status disable_checks_consolidation(); + void disable_checks_consolidation(); /** * Enables consolidation with timestamps. */ - Status set_consolidation_with_timestamps(); + void set_consolidation_with_timestamps(); /** * Set the processed conditions for writes. @@ -526,9 +514,8 @@ class Query { * * @param buffer The buffer that has the input data to be written. * @param buffer_size The size of `buffer` in bytes. - * @return Status */ - Status set_coords_buffer(void* buffer, uint64_t* buffer_size); + void set_coords_buffer(void* buffer, uint64_t* buffer_size); /** * Sets the data for a fixed/var-sized attribute/dimension. @@ -542,9 +529,8 @@ class Query { * allowed. * @param serialization_allow_new_attr If true, setting new attributes * is allowed in INITIALIZED state - * @return Status */ - Status set_data_buffer( + void set_data_buffer( const std::string& name, void* const buffer, uint64_t* const buffer_size, @@ -581,9 +567,8 @@ class Query { * allowed. * @param serialization_allow_new_attr If true, setting new attributes * is allowed in INITIALIZED state - * @return Status */ - Status set_offsets_buffer( + void set_offsets_buffer( const std::string& name, uint64_t* const buffer_offsets, uint64_t* const buffer_offsets_size, @@ -606,9 +591,8 @@ class Query { * allowed. * @param serialization_allow_new_attr If true, setting new attributes * is allowed in INITIALIZED state - * @return Status */ - Status set_validity_buffer( + void set_validity_buffer( const std::string& name, uint8_t* const buffer_validity_bytemap, uint64_t* const buffer_validity_bytemap_size, @@ -627,24 +611,22 @@ class Query { * * @param est_result_size map to set * @param max_mem_size map to set - * @return Status */ - Status set_est_result_size( + void set_est_result_size( std::unordered_map& est_result_size, std::unordered_map& max_mem_size); /** * Sets the cell layout of the query. */ - Status set_layout(Layout layout); + void set_layout(Layout layout); /** * Sets the condition for filtering results in a read query. * * @param condition The condition object. - * @return Status */ - Status set_condition(const QueryCondition& condition); + void set_condition(const QueryCondition& condition); /** * Adds an update value for an update query. @@ -654,7 +636,7 @@ class Query { * @param update_value_size The byte size of `update_value`. * @return Status */ - Status add_update_value( + void add_update_value( const char* field_name, const void* update_value, uint64_t update_value_size); @@ -700,10 +682,10 @@ class Query { void set_subarray(const tiledb::sm::Subarray& subarray); /** Sets the query subarray, without performing any checks. */ - Status set_subarray_unsafe(const Subarray& subarray); + void set_subarray_unsafe(const Subarray& subarray); /** Sets the query subarray, without performing any checks. */ - Status set_subarray_unsafe(const NDRange& subarray); + void set_subarray_unsafe(const NDRange& subarray); /** * Sets the query subarray without performing any checks. @@ -715,7 +697,7 @@ class Query { void set_subarray_unsafe(const void* subarray); /** Submits the query to the storage manager. */ - Status submit(); + void submit(); /** Returns the query status. */ QueryStatus status() const; @@ -1165,20 +1147,19 @@ class Query { * * @param skip_checks_serialization Skip checks during serialization. */ - Status create_strategy(bool skip_checks_serialization = false); + void create_strategy(bool skip_checks_serialization = false); - Status check_set_fixed_buffer(const std::string& name); + void check_set_fixed_buffer(const std::string& name); /** Checks if the buffers names have been appropriately set for the query. */ - Status check_buffer_names(); + void check_buffer_names(); /** * Internal routine for checking the completeness of all attribute * and dimensions buffers. Iteratively searches that all attributes & * dimensions buffers have been set correctly - * @return Status */ - Status check_buffers_correctness(); + void check_buffers_correctness(); /** * Returns true if only querying dimension labels. @@ -1195,7 +1176,7 @@ class Query { * only for remote global order writes and it should enforce tile alignment * for both dense and sparse arrays. */ - Status check_tile_alignment() const; + void check_tile_alignment() const; /** * Reset coord buffer markers at end of a global write submit. diff --git a/tiledb/sm/query/query_buffer.h b/tiledb/sm/query/query_buffer.h index 2fc73e6b9c2..1cdede6f498 100644 --- a/tiledb/sm/query/query_buffer.h +++ b/tiledb/sm/query/query_buffer.h @@ -45,6 +45,9 @@ using namespace tiledb::common; namespace tiledb { namespace sm { +template +using query_buffer_t = std::pair; + /** Contains the buffer(s) and buffer size(s) for some attribute/dimension. */ class QueryBuffer { public: @@ -208,6 +211,14 @@ class QueryBuffer { /* PUBLIC METHODS */ /* ********************************* */ + query_buffer_t get_data_buffer(bool is_var) const { + if (is_var) { + return {buffer_var_, buffer_var_size_}; + } else { + return {buffer_, buffer_size_}; + } + } + void set_data_buffer(void* data_buffer, uint64_t* size) { buffer_ = data_buffer; buffer_size_ = size; @@ -220,12 +231,20 @@ class QueryBuffer { original_buffer_var_size_ = *size; } + query_buffer_t get_offsets_buffer() const { + return {(uint64_t*)buffer_, buffer_size_}; + } + void set_offsets_buffer(void* offsets_buffer, uint64_t* size) { buffer_ = offsets_buffer; buffer_size_ = size; original_buffer_size_ = *size; } + query_buffer_t get_validity_buffer() const { + return {validity_vector_.buffer(), validity_vector_.buffer_size()}; + } + void set_validity_buffer(ValidityVector&& validity_vector) { validity_vector_ = std::move(validity_vector); original_validity_vector_size_ = *validity_vector_.buffer_size(); diff --git a/tiledb/sm/query_plan/test/unit_query_plan.cc b/tiledb/sm/query_plan/test/unit_query_plan.cc index 3f78ddbbefb..1a81ef25590 100644 --- a/tiledb/sm/query_plan/test/unit_query_plan.cc +++ b/tiledb/sm/query_plan/test/unit_query_plan.cc @@ -128,7 +128,7 @@ TEST_CASE_METHOD(QueryPlanFx, "Query plan dump_json", "[query_plan][dump]") { shared_ptr array_shared = std::move(array); Query query( resources_, CancellationSource(sm_.get()), sm_.get(), array_shared); - REQUIRE(query.set_layout(Layout::ROW_MAJOR).ok()); + query.set_layout(Layout::ROW_MAJOR); stats::Stats stats("foo"); Subarray subarray(array_shared.get(), &stats, logger_); @@ -138,7 +138,7 @@ TEST_CASE_METHOD(QueryPlanFx, "Query plan dump_json", "[query_plan][dump]") { std::vector data(2); uint64_t size = 2; - REQUIRE(query.set_data_buffer("attr", data.data(), &size).ok()); + query.set_data_buffer("attr", data.data(), &size); QueryPlan plan(query); diff --git a/tiledb/sm/serialization/query.cc b/tiledb/sm/serialization/query.cc index 9837702f737..d628f0ef9dd 100644 --- a/tiledb/sm/serialization/query.cc +++ b/tiledb/sm/serialization/query.cc @@ -1108,7 +1108,7 @@ Status reader_from_capnp( Subarray subarray(array, layout, query->stats(), dummy_logger, true); auto subarray_reader = reader_reader.getSubarray(); RETURN_NOT_OK(subarray_from_capnp(subarray_reader, &subarray)); - RETURN_NOT_OK(query->set_subarray_unsafe(subarray)); + query->set_subarray_unsafe(subarray); // Read state if (reader_reader.hasReadState()) @@ -1119,7 +1119,7 @@ Status reader_from_capnp( if (reader_reader.hasCondition()) { auto condition_reader = reader_reader.getCondition(); QueryCondition condition = condition_from_capnp(condition_reader); - RETURN_NOT_OK(query->set_condition(condition)); + query->set_condition(condition); } // If cap'n proto object has stats set it on c++ object @@ -1146,7 +1146,7 @@ Status index_reader_from_capnp( Subarray subarray(array, layout, query->stats(), dummy_logger, true); auto subarray_reader = reader_reader.getSubarray(); RETURN_NOT_OK(subarray_from_capnp(subarray_reader, &subarray)); - RETURN_NOT_OK(query->set_subarray_unsafe(subarray)); + query->set_subarray_unsafe(subarray); // Read state if (reader_reader.hasReadState()) @@ -1157,7 +1157,7 @@ Status index_reader_from_capnp( if (reader_reader.hasCondition()) { auto condition_reader = reader_reader.getCondition(); QueryCondition condition = condition_from_capnp(condition_reader); - RETURN_NOT_OK(query->set_condition(condition)); + query->set_condition(condition); } // If cap'n proto object has stats set it on c++ object @@ -1185,7 +1185,7 @@ Status dense_reader_from_capnp( Subarray subarray(array, layout, query->stats(), dummy_logger, true); auto subarray_reader = reader_reader.getSubarray(); RETURN_NOT_OK(subarray_from_capnp(subarray_reader, &subarray)); - RETURN_NOT_OK(query->set_subarray_unsafe(subarray)); + query->set_subarray_unsafe(subarray); // Read state if (reader_reader.hasReadState()) @@ -1196,7 +1196,7 @@ Status dense_reader_from_capnp( if (reader_reader.hasCondition()) { auto condition_reader = reader_reader.getCondition(); QueryCondition condition = condition_from_capnp(condition_reader); - RETURN_NOT_OK(query->set_condition(condition)); + query->set_condition(condition); } // If cap'n proto object has stats set it on c++ object @@ -1216,7 +1216,7 @@ Status delete_from_capnp( if (delete_reader.hasCondition()) { auto condition_reader = delete_reader.getCondition(); QueryCondition condition = condition_from_capnp(condition_reader); - RETURN_NOT_OK(query->set_condition(condition)); + query->set_condition(condition); } // If cap'n proto object has stats set it on c++ object @@ -1617,7 +1617,7 @@ Status query_from_capnp( // Make sure we have the right query strategy in place. bool force_legacy_reader = query_type == QueryType::READ && query_reader.hasReader(); - RETURN_NOT_OK(query->reset_strategy_with_layout(layout, force_legacy_reader)); + query->reset_strategy_with_layout(layout, force_legacy_reader); // Reset QueryStatus to UNINITIALIZED // Note: this is a pre-C.41 hack. At present, Strategy creation is the point @@ -1719,28 +1719,23 @@ Status query_from_capnp( if (var_size) { if (!nullable) { - RETURN_NOT_OK(query->get_data_buffer( - name.c_str(), &existing_buffer, &existing_buffer_size_ptr)); - RETURN_NOT_OK(query->get_offsets_buffer( - name.c_str(), - &existing_offset_buffer, - &existing_offset_buffer_size_ptr)); + std::tie(existing_buffer, existing_buffer_size_ptr) = + query->get_data_buffer(name.c_str()); + std::tie(existing_offset_buffer, existing_offset_buffer_size_ptr) = + query->get_offsets_buffer(name.c_str()); if (existing_offset_buffer_size_ptr != nullptr) existing_offset_buffer_size = *existing_offset_buffer_size_ptr; if (existing_buffer_size_ptr != nullptr) existing_buffer_size = *existing_buffer_size_ptr; } else { - RETURN_NOT_OK(query->get_data_buffer( - name.c_str(), &existing_buffer, &existing_buffer_size_ptr)); - RETURN_NOT_OK(query->get_offsets_buffer( - name.c_str(), - &existing_offset_buffer, - &existing_offset_buffer_size_ptr)); - RETURN_NOT_OK(query->get_validity_buffer( - name.c_str(), - &existing_validity_buffer, - &existing_validity_buffer_size_ptr)); + std::tie(existing_buffer, existing_buffer_size_ptr) = + query->get_data_buffer(name.c_str()); + std::tie(existing_offset_buffer, existing_offset_buffer_size_ptr) = + query->get_offsets_buffer(name.c_str()); + std::tie( + existing_validity_buffer, existing_validity_buffer_size_ptr) = + query->get_validity_buffer(name.c_str()); if (existing_offset_buffer_size_ptr != nullptr) existing_offset_buffer_size = *existing_offset_buffer_size_ptr; @@ -1751,18 +1746,17 @@ Status query_from_capnp( } } else { if (!nullable) { - RETURN_NOT_OK(query->get_data_buffer( - name.c_str(), &existing_buffer, &existing_buffer_size_ptr)); + std::tie(existing_buffer, existing_buffer_size_ptr) = + query->get_data_buffer(name.c_str()); if (existing_buffer_size_ptr != nullptr) existing_buffer_size = *existing_buffer_size_ptr; } else { - RETURN_NOT_OK(query->get_data_buffer( - name.c_str(), &existing_buffer, &existing_buffer_size_ptr)); - RETURN_NOT_OK(query->get_validity_buffer( - name.c_str(), - &existing_validity_buffer, - &existing_validity_buffer_size_ptr)); + std::tie(existing_buffer, existing_buffer_size_ptr) = + query->get_data_buffer(name.c_str()); + std::tie( + existing_validity_buffer, existing_validity_buffer_size_ptr) = + query->get_validity_buffer(name.c_str()); if (existing_buffer_size_ptr != nullptr) existing_buffer_size = *existing_buffer_size_ptr; @@ -2003,40 +1997,40 @@ Status query_from_capnp( attr_state->var_len_data.swap(varlen_buff); attr_state->validity_len_data.swap(validitylen_buff); if (var_size) { - throw_if_not_ok(query->set_data_buffer( + query->set_data_buffer( name, attr_state->var_len_data.data(), &attr_state->var_len_size, allocate_buffers, - true)); - throw_if_not_ok(query->set_offsets_buffer( + true); + query->set_offsets_buffer( name, attr_state->fixed_len_data.data_as(), &attr_state->fixed_len_size, allocate_buffers, - true)); + true); if (nullable) { - throw_if_not_ok(query->set_validity_buffer( + query->set_validity_buffer( name, attr_state->validity_len_data.data_as(), &attr_state->validity_len_size, allocate_buffers, - true)); + true); } } else { - throw_if_not_ok(query->set_data_buffer( + query->set_data_buffer( name, attr_state->fixed_len_data.data(), &attr_state->fixed_len_size, allocate_buffers, - true)); + true); if (nullable) { - throw_if_not_ok(query->set_validity_buffer( + query->set_validity_buffer( name, attr_state->validity_len_data.data_as(), &attr_state->validity_len_size, allocate_buffers, - true)); + true); } } } else if (query_type == QueryType::WRITE) { @@ -2064,25 +2058,25 @@ Status query_from_capnp( attr_state->var_len_data.swap(varlen_buff); attr_state->validity_len_data.swap(validity_buff); - throw_if_not_ok(query->set_data_buffer( + query->set_data_buffer( name, varlen_data, &attr_state->var_len_size, allocate_buffers, - true)); - throw_if_not_ok(query->set_offsets_buffer( + true); + query->set_offsets_buffer( name, offsets, &attr_state->fixed_len_size, allocate_buffers, - true)); + true); if (nullable) { - throw_if_not_ok(query->set_validity_buffer( + query->set_validity_buffer( name, validity, &attr_state->validity_len_size, allocate_buffers, - true)); + true); } } else { auto* data = attribute_buffer_start; @@ -2104,15 +2098,15 @@ Status query_from_capnp( attr_state->var_len_data.swap(varlen_buff); attr_state->validity_len_data.swap(validity_buff); - throw_if_not_ok(query->set_data_buffer( - name, data, &attr_state->fixed_len_size, allocate_buffers, true)); + query->set_data_buffer( + name, data, &attr_state->fixed_len_size, allocate_buffers, true); if (nullable) { - throw_if_not_ok(query->set_validity_buffer( + query->set_validity_buffer( name, validity, &attr_state->validity_len_size, allocate_buffers, - true)); + true); } } } else { @@ -2210,7 +2204,7 @@ Status query_from_capnp( Subarray subarray(array, layout, query->stats(), dummy_logger, true); auto subarray_reader = writer_reader.getSubarrayRanges(); RETURN_NOT_OK(subarray_from_capnp(subarray_reader, &subarray)); - RETURN_NOT_OK(query->set_subarray_unsafe(subarray)); + query->set_subarray_unsafe(subarray); } } } else { @@ -2671,7 +2665,7 @@ Status query_est_result_size_reader_to_capnp( return Status::Ok(); } -Status query_est_result_size_reader_from_capnp( +void query_est_result_size_reader_from_capnp( const capnp::EstimatedResultSize::Reader& est_result_size_reader, Query* const query) { using namespace tiledb::sm; @@ -2703,7 +2697,7 @@ Status query_est_result_size_reader_from_capnp( memory_size.getSizeValidity()}); } - return query->set_est_result_size(est_result_sizes_map, max_memory_sizes_map); + query->set_est_result_size(est_result_sizes_map, max_memory_sizes_map); } Status query_est_result_size_serialize( @@ -2761,8 +2755,8 @@ Status query_est_result_size_deserialize( serialized_buffer, estimated_result_size_builder); capnp::EstimatedResultSize::Reader estimated_result_size_reader = estimated_result_size_builder.asReader(); - RETURN_NOT_OK(query_est_result_size_reader_from_capnp( - estimated_result_size_reader, query)); + query_est_result_size_reader_from_capnp( + estimated_result_size_reader, query); break; } case SerializationType::CAPNP: { @@ -2773,8 +2767,8 @@ Status query_est_result_size_deserialize( serialized_buffer.size() / sizeof(::capnp::word))); capnp::EstimatedResultSize::Reader estimated_result_size_reader = reader.getRoot(); - RETURN_NOT_OK(query_est_result_size_reader_from_capnp( - estimated_result_size_reader, query)); + query_est_result_size_reader_from_capnp( + estimated_result_size_reader, query); break; } default: { @@ -3128,12 +3122,12 @@ void ordered_dim_label_reader_from_capnp( Subarray subarray(array, layout, query->stats(), dummy_logger, false); auto subarray_reader = reader_reader.getSubarray(); throw_if_not_ok(subarray_from_capnp(subarray_reader, &subarray)); - throw_if_not_ok(query->set_subarray_unsafe(subarray)); + query->set_subarray_unsafe(subarray); // OrderedDimLabelReader requires an initialized subarray for construction. query->set_dimension_label_ordered_read( reader_reader.getDimLabelIncreasing()); - throw_if_not_ok(query->reset_strategy_with_layout(layout, false)); + query->reset_strategy_with_layout(layout, false); reader = dynamic_cast(query->strategy(true)); // If cap'n proto object has stats set it on c++ object diff --git a/tiledb/sm/storage_manager/storage_manager.cc b/tiledb/sm/storage_manager/storage_manager.cc index b67261aaa0c..4fef9e88d7b 100644 --- a/tiledb/sm/storage_manager/storage_manager.cc +++ b/tiledb/sm/storage_manager/storage_manager.cc @@ -129,12 +129,10 @@ void StorageManagerCanonical::increment_in_progress() { queries_in_progress_cv_.notify_all(); } -Status StorageManagerCanonical::query_submit(Query* query) { +void StorageManagerCanonical::query_submit(Query* query) { // Process the query QueryInProgress in_progress(this); - auto st = query->process(); - - return st; + query->process(); } void StorageManagerCanonical::wait_for_zero_in_progress() { diff --git a/tiledb/sm/storage_manager/storage_manager_canonical.h b/tiledb/sm/storage_manager/storage_manager_canonical.h index d7e9dd93cf8..300de144790 100644 --- a/tiledb/sm/storage_manager/storage_manager_canonical.h +++ b/tiledb/sm/storage_manager/storage_manager_canonical.h @@ -106,7 +106,7 @@ class StorageManagerCanonical { bool cancellation_in_progress() const; /** Submits a query for (sync) execution. */ - Status query_submit(Query* query); + void query_submit(Query* query); private: /* ********************************* */