From e0bc0dd38bf4907704d7c5a6066e0a59cec0d744 Mon Sep 17 00:00:00 2001 From: Ypatia Tsavliri Date: Tue, 9 Apr 2024 10:54:25 +0300 Subject: [PATCH] Port more tests to REST CI (#4838) As per title, more tests in tiledb_unit are adapted to run on the REST CI runner. After this PR is merged we'll have 160 tests ported to REST-CI runner, of which 143 will be running and passing and 17 will be disabled until the issues found and logged here:https://app.shortcut.com/tiledb-inc/story/40489/issues-found-while-running-tiledb-unit-core-tests-against-rest-cloud-server are fixed. --- TYPE: NO_HISTORY DESC: Port more tests to REST CI --- test/src/cpp-integration-query-condition.cc | 81 +- test/src/test-capi-consolidation-plan.cc | 71 +- test/src/unit-backwards_compat.cc | 47 +- test/src/unit-capi-array.cc | 296 ++--- test/src/unit-capi-attributes.cc | 152 +-- test/src/unit-capi-consolidation.cc | 1076 ++++++++--------- test/src/unit-capi-dense_array.cc | 954 ++++----------- test/src/unit-capi-dense_neg.cc | 92 +- test/src/unit-capi-group.cc | 10 +- test/src/unit-capi-incomplete-2.cc | 269 +---- test/src/unit-capi-incomplete.cc | 301 +---- test/src/unit-capi-nullable.cc | 44 +- test/src/unit-capi-rest-dense_array.cc | 6 +- test/src/unit-capi-serialized_queries.cc | 341 +----- ...-capi-serialized_queries_using_subarray.cc | 241 +--- test/src/unit-capi-sparse_array.cc | 981 ++++++--------- test/src/unit-capi-sparse_heter.cc | 67 +- test/src/unit-capi-sparse_neg.cc | 47 +- test/src/unit-capi-sparse_neg_2.cc | 46 +- test/src/unit-capi-string.cc | 170 +-- test/src/unit-capi-string_dims.cc | 517 ++------ ...it-cppapi-consolidation-with-timestamps.cc | 265 +--- test/src/unit-cppapi-string-dims.cc | 123 +- test/src/unit-query-plan.cc | 55 +- test/src/unit-sparse-global-order-reader.cc | 80 +- test/support/src/vfs_helpers.cc | 9 + test/support/src/vfs_helpers.h | 34 +- 27 files changed, 1850 insertions(+), 4525 deletions(-) diff --git a/test/src/cpp-integration-query-condition.cc b/test/src/cpp-integration-query-condition.cc index d18e2e42872..4c794769f9b 100644 --- a/test/src/cpp-integration-query-condition.cc +++ b/test/src/cpp-integration-query-condition.cc @@ -36,6 +36,7 @@ #include #include +#include #include #include "tiledb/sm/cpp_api/tiledb" #include "tiledb/sm/misc/utils.h" @@ -91,6 +92,7 @@ inline int index_from_row_col(int r, int c) { * @param set_dups Whether the array allows coordinate duplicates. * @param a_data_read Data buffer to store cell values on attribute a. * @param b_data_read Data buffer to store cell values on attribute b. + * @param array_uri URI of array to create. */ void create_array( Context& ctx, @@ -98,7 +100,8 @@ void create_array( bool set_dups, bool add_utf8_attr, std::vector& a_data_read, - std::vector& b_data_read) { + std::vector& b_data_read, + const std::string& array_uri = array_name) { Domain domain(ctx); domain.add_dimension(Dimension::create(ctx, "rows", {{1, num_rows}}, 4)) .add_dimension(Dimension::create(ctx, "cols", {{1, num_rows}}, 4)); @@ -123,7 +126,7 @@ void create_array( attr_c.set_nullable(true); schema.add_attribute(attr_c); } - Array::create(array_name, schema); + Array::create(array_uri, schema); // Write some initial data and close the array. std::vector row_dims; @@ -179,7 +182,7 @@ void create_array( } if (array_type == TILEDB_SPARSE) { - Array array_w(ctx, array_name, TILEDB_WRITE); + Array array_w(ctx, array_uri, TILEDB_WRITE); Query query_w(ctx, array_w); query_w.set_layout(TILEDB_UNORDERED) .set_data_buffer("rows", row_dims) @@ -197,7 +200,7 @@ void create_array( query_w.finalize(); array_w.close(); } else if (array_type == TILEDB_DENSE) { - Array array_w(ctx, array_name, TILEDB_WRITE); + Array array_w(ctx, array_uri, TILEDB_WRITE); Query query_w(ctx, array_w); query_w.set_layout(TILEDB_ROW_MAJOR) .set_data_buffer("a", a_data) @@ -215,7 +218,7 @@ void create_array( } // Open and read the entire array to save data for future comparisons. - Array array1(ctx, array_name, TILEDB_READ); + Array array1(ctx, array_uri, TILEDB_READ); Query query1(ctx, array1); query1.set_layout(TILEDB_ROW_MAJOR) .set_data_buffer("a", a_data_read) @@ -316,15 +319,12 @@ struct TestParams { TEST_CASE( "Testing read query with empty QC, with no range.", - "[query][query-condition][empty]") { + "[query][query-condition][empty][rest]") { // Initial setup. std::srand(static_cast(time(0))); - Context ctx; - VFS vfs(ctx); - - if (vfs.is_dir(array_name)) { - vfs.remove_dir(array_name); - } + test::VFSTestSetup vfs_test_setup; + Context ctx{vfs_test_setup.ctx()}; + auto array_uri{vfs_test_setup.array_uri(array_name)}; // Create an empty query condition QueryCondition qc(ctx); @@ -351,7 +351,8 @@ TEST_CASE( params.set_dups_, params.add_utf8_attr_, a_data_read, - b_data_read); + b_data_read, + array_uri); // Create the query, which reads over the entire array with query condition Config config; @@ -359,8 +360,10 @@ TEST_CASE( config.set("sm.query.sparse_global_order.reader", "legacy"); config.set("sm.query.sparse_unordered_with_dups.reader", "legacy"); } - Context ctx2 = Context(config); - Array array(ctx2, array_name, TILEDB_READ); + + auto vfs_test_setup2 = tiledb::test::VFSTestSetup(config.ptr().get(), false); + auto ctx2 = vfs_test_setup2.ctx(); + Array array(ctx2, array_uri, TILEDB_READ); Query query(ctx2, array); // Set a subarray for dense. @@ -378,15 +381,12 @@ TEST_CASE( TEST_CASE( "Testing read query with basic QC, with no range.", - "[query][query-condition]") { + "[query][query-condition][rest]") { // Initial setup. std::srand(static_cast(time(0))); - Context ctx; - VFS vfs(ctx); - - if (vfs.is_dir(array_name)) { - vfs.remove_dir(array_name); - } + test::VFSTestSetup vfs_test_setup; + Context ctx{vfs_test_setup.ctx()}; + auto array_uri{vfs_test_setup.array_uri(array_name)}; // Define query condition (b < 4.0). QueryCondition qc(ctx); @@ -415,7 +415,8 @@ TEST_CASE( params.set_dups_, params.add_utf8_attr_, a_data_read, - b_data_read); + b_data_read, + array_uri); // Create the query, which reads over the entire array with query condition // (b < 4.0). @@ -424,8 +425,9 @@ TEST_CASE( config.set("sm.query.sparse_global_order.reader", "legacy"); config.set("sm.query.sparse_unordered_with_dups.reader", "legacy"); } - Context ctx2 = Context(config); - Array array(ctx2, array_name, TILEDB_READ); + auto vfs_test_setup2 = tiledb::test::VFSTestSetup(config.ptr().get(), false); + auto ctx2 = vfs_test_setup2.ctx(); + Array array(ctx2, array_uri, TILEDB_READ); Query query(ctx2, array); // Set a subarray for dense. @@ -500,23 +502,16 @@ TEST_CASE( query.finalize(); array.close(); - - if (vfs.is_dir(array_name)) { - vfs.remove_dir(array_name); - } } TEST_CASE( "Testing read query with basic negated QC, with no range.", - "[query][query-condition][negation]") { + "[query][query-condition][negation][rest]") { // Initial setup. std::srand(static_cast(time(0))); - Context ctx; - VFS vfs(ctx); - - if (vfs.is_dir(array_name)) { - vfs.remove_dir(array_name); - } + test::VFSTestSetup vfs_test_setup; + Context ctx{vfs_test_setup.ctx()}; + auto array_uri{vfs_test_setup.array_uri(array_name)}; // Define query condition (b < 4.0). QueryCondition qc(ctx); @@ -547,7 +542,8 @@ TEST_CASE( params.set_dups_, params.add_utf8_attr_, a_data_read, - b_data_read); + b_data_read, + array_uri); // Create the query, which reads over the entire array with query condition // (b < 4.0). @@ -556,8 +552,11 @@ TEST_CASE( config.set("sm.query.sparse_global_order.reader", "legacy"); config.set("sm.query.sparse_unordered_with_dups.reader", "legacy"); } - Context ctx2 = Context(config); - Array array(ctx2, array_name, TILEDB_READ); + + vfs_test_setup.update_config(config.ptr().get()); + Context ctx2 = vfs_test_setup.ctx(); + + Array array(ctx2, array_uri, TILEDB_READ); Query query(ctx2, array); // Set a subarray for dense. @@ -632,10 +631,6 @@ TEST_CASE( query.finalize(); array.close(); - - if (vfs.is_dir(array_name)) { - vfs.remove_dir(array_name); - } } TEST_CASE( diff --git a/test/src/test-capi-consolidation-plan.cc b/test/src/test-capi-consolidation-plan.cc index 11e6ea64e6b..39c5316becb 100644 --- a/test/src/test-capi-consolidation-plan.cc +++ b/test/src/test-capi-consolidation-plan.cc @@ -43,16 +43,9 @@ using namespace tiledb; using namespace tiledb::test; -#ifndef TILEDB_TESTS_ENABLE_REST -constexpr bool rest_tests = false; -#else -constexpr bool rest_tests = true; -#endif - struct ConsolidationPlanFx { // Constructors/destructors. ConsolidationPlanFx(); - ~ConsolidationPlanFx(); // Functions. void create_sparse_array(bool allows_dups = false, bool encrypt = false); @@ -67,38 +60,24 @@ struct ConsolidationPlanFx { bool is_array(const std::string& array_name); void check_last_error(std::string expected); - // TileDB context. - Context ctx_; - // Full URI initialized using fs_vec_ random temp directory. - std::string array_name_; + VFSTestSetup vfs_test_setup_; - // Vector of supported filsystems - tiledb_vfs_handle_t* vfs_c_{nullptr}; - tiledb_ctx_handle_t* ctx_c_{nullptr}; - const std::vector> fs_vec_; + // TileDB context + tiledb_ctx_t* ctx_c_; + std::string array_name_; + Context ctx_; std::string key_ = "0123456789abcdeF0123456789abcdeF"; const tiledb_encryption_type_t enc_type_ = TILEDB_AES_256_GCM; }; -ConsolidationPlanFx::ConsolidationPlanFx() - : fs_vec_(test::vfs_test_get_fs_vec()) { +ConsolidationPlanFx::ConsolidationPlanFx() { Config config; config.set("sm.consolidation.buffer_size", "1000"); - REQUIRE( - test::vfs_test_init(fs_vec_, &ctx_c_, &vfs_c_, config.ptr().get()).ok()); - ctx_ = Context(ctx_c_); - std::string temp_dir = fs_vec_[0]->temp_dir(); - if constexpr (rest_tests) { - array_name_ = "tiledb://unit/"; - } - array_name_ += temp_dir + "test_consolidation_plan_array"; - test::vfs_test_create_temp_dir(ctx_c_, vfs_c_, temp_dir); -} - -ConsolidationPlanFx::~ConsolidationPlanFx() { - Array::delete_array(ctx_, array_name_); - REQUIRE(test::vfs_test_close(fs_vec_, ctx_c_, vfs_c_).ok()); + vfs_test_setup_.update_config(config.ptr().get()); + ctx_c_ = vfs_test_setup_.ctx_c; + ctx_ = vfs_test_setup_.ctx(); + array_name_ = vfs_test_setup_.array_uri("test_consolidation_plan_array"); } void ConsolidationPlanFx::create_sparse_array(bool allows_dups, bool encrypt) { @@ -174,7 +153,7 @@ void ConsolidationPlanFx::write_sparse( void ConsolidationPlanFx::check_last_error(std::string expected) { const char* msg = "unset"; tiledb_error_t* err{nullptr}; - tiledb_ctx_get_last_error(ctx_.ptr().get(), &err); + tiledb_ctx_get_last_error(ctx_c_, &err); if (err != nullptr) { tiledb_error_message(err, &msg); } @@ -193,23 +172,20 @@ TEST_CASE_METHOD( tiledb_consolidation_plan_t* consolidation_plan{}; CHECK( - TILEDB_OK == tiledb_consolidation_plan_create_with_mbr( - ctx_.ptr().get(), - array.ptr().get(), - 1024 * 1024, - &consolidation_plan)); + TILEDB_OK == + tiledb_consolidation_plan_create_with_mbr( + ctx_c_, array.ptr().get(), 1024 * 1024, &consolidation_plan)); uint64_t num_nodes = 11; CHECK( TILEDB_OK == tiledb_consolidation_plan_get_num_nodes( - ctx_.ptr().get(), consolidation_plan, &num_nodes)); + ctx_c_, consolidation_plan, &num_nodes)); CHECK(num_nodes == 0); uint64_t num_fragments = 11; CHECK( - TILEDB_ERR == - tiledb_consolidation_plan_get_num_fragments( - ctx_.ptr().get(), consolidation_plan, 0, &num_fragments)); + TILEDB_ERR == tiledb_consolidation_plan_get_num_fragments( + ctx_c_, consolidation_plan, 0, &num_fragments)); CHECK(num_fragments == 11); check_last_error( "Error: ConsolidationPlan: Trying to access a node that doesn't exist."); @@ -217,7 +193,7 @@ TEST_CASE_METHOD( const char* frag_uri = nullptr; CHECK( TILEDB_ERR == tiledb_consolidation_plan_get_fragment_uri( - ctx_.ptr().get(), consolidation_plan, 0, 0, &frag_uri)); + ctx_c_, consolidation_plan, 0, 0, &frag_uri)); CHECK(frag_uri == nullptr); check_last_error( "Error: ConsolidationPlan: Trying to access a node that doesn't exist."); @@ -236,16 +212,13 @@ TEST_CASE_METHOD( tiledb_consolidation_plan_t* consolidation_plan{}; CHECK( - TILEDB_OK == tiledb_consolidation_plan_create_with_mbr( - ctx_.ptr().get(), - array.ptr().get(), - 1024 * 1024, - &consolidation_plan)); + TILEDB_OK == + tiledb_consolidation_plan_create_with_mbr( + ctx_c_, array.ptr().get(), 1024 * 1024, &consolidation_plan)); // Check dump char* str = nullptr; - tiledb_consolidation_plan_dump_json_str( - ctx_.ptr().get(), consolidation_plan, &str); + tiledb_consolidation_plan_dump_json_str(ctx_c_, consolidation_plan, &str); std::string plan(str); CHECK(plan == "{\n \"nodes\": [\n ]\n}\n"); diff --git a/test/src/unit-backwards_compat.cc b/test/src/unit-backwards_compat.cc index 425e7afdf7f..09778fd6f62 100644 --- a/test/src/unit-backwards_compat.cc +++ b/test/src/unit-backwards_compat.cc @@ -1247,17 +1247,6 @@ TEST_CASE( "Backwards compatibility: Upgrades an array of older version and " "write/read it", "[backwards-compat][upgrade-version][write-read-new-version]") { - bool serialize = false, refactored_query_v2 = false; - SECTION("no serialization") { - serialize = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled") { - serialize = true; - refactored_query_v2 = GENERATE(true, false); - } -#endif - std::string array_name(arrays_dir + "/non_split_coords_v1_4_0"); Context ctx; std::string schema_folder; @@ -1281,13 +1270,7 @@ TEST_CASE( .set_data_buffer("d2", d2_read1); ServerQueryBuffers server_buffers; - submit_query_wrapper( - ctx, - array_name, - &query_read1, - server_buffers, - serialize, - refactored_query_v2); + query_read1.submit(); array_read1.close(); for (int i = 0; i < 4; i++) { @@ -1308,30 +1291,12 @@ TEST_CASE( query_write.set_data_buffer("d1", d1_write); query_write.set_data_buffer("d2", d2_write); - submit_query_wrapper( - ctx, - array_name, - &query_write, - server_buffers, - serialize, - refactored_query_v2); + query_write.submit_and_finalize(); array_write.close(); FragmentInfo fragment_info(ctx, array_name); fragment_info.load(); - - if (serialize) { - FragmentInfo deserialized_fragment_info(ctx, array_name); - tiledb_fragment_info_serialize( - ctx.ptr().get(), - array_name.c_str(), - fragment_info.ptr().get(), - deserialized_fragment_info.ptr().get(), - tiledb_serialization_type_t(0)); - fragment_info = deserialized_fragment_info; - } - fragment_uri = fragment_info.fragment_uri(1); // old version fragment @@ -1353,13 +1318,7 @@ TEST_CASE( .set_data_buffer("d1", d1_read2) .set_data_buffer("d2", d2_read2); - submit_query_wrapper( - ctx, - array_name, - &query_read2, - server_buffers, - serialize, - refactored_query_v2); + query_read2.submit(); array_read2.close(); for (int i = 0; i < 2; i++) { diff --git a/test/src/unit-capi-array.cc b/test/src/unit-capi-array.cc index 123212deb8d..3f8633119bb 100644 --- a/test/src/unit-capi-array.cc +++ b/test/src/unit-capi-array.cc @@ -93,12 +93,6 @@ struct ArrayFx { tiledb_encryption_type_t encryption_type_ = TILEDB_NO_ENCRYPTION; const char* encryption_key_ = nullptr; - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - tiledb::test::ServerQueryBuffers server_buffers_; - // Functions ArrayFx(); ~ArrayFx(); @@ -391,9 +385,7 @@ void ArrayFx::write_fragment(tiledb_array_t* array, uint64_t timestamp) { CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query, "a", buffer, &buffer_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx_, query); - CHECK(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx_, query); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Clean up @@ -470,7 +462,9 @@ TEST_CASE_METHOD( } TEST_CASE_METHOD( - ArrayFx, "C API: Test array with encryption", "[capi][array][encryption]") { + ArrayFx, + "C API: Test array with encryption", + "[capi][array][encryption][non-rest]") { // Create array schema tiledb_array_schema_t* array_schema; int rc = tiledb_array_schema_alloc(ctx_, TILEDB_SPARSE, &array_schema); @@ -883,28 +877,22 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ArrayFx, "C API: Test opening array at timestamp, reads", - "[capi][array][open-at][reads]") { + "[capi][array][open-at][reads][rest]") { // TODO: refactor for each supported FS. std::string temp_dir = fs_vec_[0]->temp_dir(); + std::string array_path = temp_dir + "array-open-at-reads"; + std::string array_name = vfs_array_uri(fs_vec_[0], array_path); - std::string array_name = temp_dir + "array-open-at-reads"; SECTION("- without encryption") { encryption_type_ = TILEDB_NO_ENCRYPTION; encryption_key_ = nullptr; - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif } - SECTION("- with encryption") { - encryption_type_ = TILEDB_AES_256_GCM; - encryption_key_ = "0123456789abcdeF0123456789abcdeF"; + if (!fs_vec_[0]->is_rest()) { + SECTION("- with encryption") { + encryption_type_ = TILEDB_AES_256_GCM; + encryption_key_ = "0123456789abcdeF0123456789abcdeF"; + } } create_temp_dir(temp_dir); @@ -951,13 +939,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_a1, &buffer_a1_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1006,13 +988,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_upd, &buffer_upd_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1025,7 +1001,7 @@ TEST_CASE_METHOD( rc = tiledb_vfs_ls( ctx_, vfs_, - get_commit_dir(array_name).c_str(), + get_commit_dir(array_path).c_str(), &get_fragment_timestamps, &fragment_timestamps); CHECK(rc == TILEDB_OK); @@ -1070,13 +1046,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1134,13 +1104,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1191,13 +1155,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1254,13 +1212,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Clean up but don't close the array yet (we will reopen it). @@ -1291,13 +1243,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Clean up but don't close the array yet (we will reopen it). @@ -1331,13 +1277,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1401,13 +1341,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1471,13 +1405,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1511,28 +1439,22 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ArrayFx, "C API: Test opening array at timestamp, writes", - "[capi][array][open-at][writes]") { + "[capi][array][open-at][writes][rest-fails][sc-42722]") { // TODO: refactor for each supported FS. std::string temp_dir = fs_vec_[0]->temp_dir(); + std::string array_name = + vfs_array_uri(fs_vec_[0], temp_dir + "array-open-at-writes"); - std::string array_name = temp_dir + "array-open-at-writes"; SECTION("- without encryption") { encryption_type_ = TILEDB_NO_ENCRYPTION; encryption_key_ = nullptr; - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif } - SECTION("- with encryption") { - encryption_type_ = TILEDB_AES_256_GCM; - encryption_key_ = "0123456789abcdeF0123456789abcdeF"; + if (!fs_vec_[0]->is_rest()) { + SECTION("- with encryption") { + encryption_type_ = TILEDB_AES_256_GCM; + encryption_key_ = "0123456789abcdeF0123456789abcdeF"; + } } create_temp_dir(temp_dir); @@ -1584,13 +1506,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_a1, &buffer_a1_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Get written timestamp @@ -1655,13 +1571,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1712,13 +1622,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, "a", buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -1739,10 +1643,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ArrayFx, "C API: Check writing coordinates out of bounds", - "[capi][array][array-write-coords-oob]") { - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "array-write-coords-oob"; + "[capi][array][array-write-coords-oob][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); + std::string array_name = + vfs_array_uri(fs_vec_[0], temp_dir + "array-write-coords-oob"); create_temp_dir(temp_dir); int dimension = 0; @@ -1756,7 +1660,6 @@ TEST_CASE_METHOD( // Create TileDB context tiledb_config_t* cfg = nullptr; tiledb_error_t* err = nullptr; - tiledb_ctx_t* ctx = nullptr; SECTION("- Check out-of-bounds coordinates") { check_coords_oob = true; @@ -1842,59 +1745,58 @@ TEST_CASE_METHOD( } } - REQUIRE(tiledb_ctx_alloc(cfg, &ctx) == TILEDB_OK); - REQUIRE(err == nullptr); + tiledb_ctx_free(&ctx_); + tiledb_vfs_free(&vfs_); + // reallocate with input config + vfs_test_init(fs_vec_, &ctx_, &vfs_, cfg).ok(); tiledb_config_free(&cfg); // Open array tiledb_array_t* array; - rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Submit query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_GLOBAL_ORDER); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); CHECK(rc == TILEDB_OK); - rc = - tiledb_query_set_data_buffer(ctx, query, "a", buffer_a1, &buffer_a1_size); + rc = tiledb_query_set_data_buffer( + ctx_, query, "a", buffer_a1, &buffer_a1_size); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, "d1", buffer_coords_dim1, &buffer_coords_size); + ctx_, query, "d1", buffer_coords_dim1, &buffer_coords_size); CHECK(rc == TILEDB_OK); if (dimension == 2) { rc = tiledb_query_set_data_buffer( - ctx, query, "d2", buffer_coords_dim2, &buffer_coords_size); + ctx_, query, "d2", buffer_coords_dim2, &buffer_coords_size); CHECK(rc == TILEDB_OK); } - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit_and_finalize(ctx_, query); if (check_coords_oob) { CHECK(rc == TILEDB_ERR); } else { CHECK(rc == TILEDB_OK); } - rc = tiledb_query_finalize(ctx, query); - CHECK(rc == TILEDB_OK); // Close array and clean up - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); tiledb_array_free(&array); tiledb_query_free(&query); - tiledb_ctx_free(&ctx); remove_temp_dir(temp_dir); } TEST_CASE_METHOD( - ArrayFx, "C API: Test empty array", "[capi][array][array-empty]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "array_empty"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + ArrayFx, "C API: Test empty array", "[capi][array][array-empty][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); + std::string array_name = vfs_array_uri(fs_vec_[0], temp_dir + "array_empty"); + + create_temp_dir(temp_dir); create_sparse_vector(array_name); @@ -1937,15 +1839,17 @@ TEST_CASE_METHOD( tiledb_array_free(&array); tiledb_query_free(&query); - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + remove_temp_dir(temp_dir); } TEST_CASE_METHOD( - ArrayFx, "C API: Test deletion of array", "[capi][array][delete]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "array_delete"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + ArrayFx, "C API: Test deletion of array", "[capi][array][delete][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); + std::string array_path = temp_dir + "array_delete"; + std::string array_name = vfs_array_uri(fs_vec_[0], array_path); + + create_temp_dir(temp_dir); + create_dense_vector(array_name); // Conditionally consolidate @@ -1961,11 +1865,17 @@ TEST_CASE_METHOD( write_fragment(array, 5); // Check write - CHECK(tiledb::test::num_commits(array_name) == 3); - CHECK(tiledb::test::num_fragments(array_name) == 3); + // Get the number of write files in the commit directory + tiledb::Context ctx(ctx_, false); + tiledb::VFS vfs(ctx); + CommitsDirectory commits_dir(vfs, array_path); + CHECK(commits_dir.file_count(constants::write_file_suffix) == 3); + auto uris = vfs.ls( + array_path + "/" + tiledb::sm::constants::array_fragments_dir_name); + CHECK(static_cast(uris.size()) == 3); // Conditionally consolidate commits - if (consolidate) { + if (consolidate && !fs_vec_[0]->is_rest()) { tiledb_config_t* cfg; tiledb_error_t* err = nullptr; rc = tiledb_config_alloc(&cfg, &err); @@ -1979,16 +1889,22 @@ TEST_CASE_METHOD( tiledb_config_free(&cfg); // Validate working directory - CHECK(tiledb::test::num_commits(array_name) == 3); - CHECK(tiledb::test::num_fragments(array_name) == 3); + CommitsDirectory commits_dir2(vfs, array_path); + CHECK(commits_dir2.file_count(constants::write_file_suffix) == 3); + auto uris2 = vfs.ls( + array_path + "/" + tiledb::sm::constants::array_fragments_dir_name); + CHECK(static_cast(uris2.size()) == 3); } // Delete array data rc = tiledb_array_delete(ctx_, array_name.c_str()); // Validate working directory after delete - CHECK(tiledb::test::num_commits(array_name) == 0); - CHECK(tiledb::test::num_fragments(array_name) == 0); + CommitsDirectory commits_dir3(vfs, array_path); + CHECK(commits_dir3.file_count(constants::write_file_suffix) == 0); + auto uris3 = vfs.ls( + array_path + "/" + tiledb::sm::constants::array_fragments_dir_name); + CHECK(static_cast(uris3.size()) == 0); // Try to open array rc = tiledb_array_open(ctx_, array, TILEDB_READ); @@ -1996,18 +1912,18 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + remove_temp_dir(temp_dir); } TEST_CASE_METHOD( ArrayFx, "C API: Test query errors, getting subarray info from write queries in " "sparse arrays", - "[capi][query][error][sparse]") { - SupportedFsLocal local_fs; + "[capi][query][error][sparse][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "query_error_sparse"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + vfs_array_uri(fs_vec_[0], temp_dir + "query_error_sparse"); + create_temp_dir(temp_dir); create_sparse_vector(array_name); @@ -2053,17 +1969,17 @@ TEST_CASE_METHOD( tiledb_array_free(&array); tiledb_query_free(&query); - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + remove_temp_dir(temp_dir); } TEST_CASE_METHOD( ArrayFx, "C API: Test query errors, dense writes", - "[capi][query][error][dense]") { - SupportedFsLocal local_fs; + "[capi][query][error][dense][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "query_error_dense"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + vfs_array_uri(fs_vec_[0], temp_dir + "query_error_dense"); + create_temp_dir(temp_dir); create_dense_array(array_name); @@ -2127,17 +2043,18 @@ TEST_CASE_METHOD( tiledb_array_free(&array); tiledb_query_free(&query); - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + remove_temp_dir(temp_dir); } TEST_CASE_METHOD( ArrayFx, "C API: Test query errors, dense unordered writes", - "[capi][query][error][dense]") { - SupportedFsLocal local_fs; + "[capi][query][error][dense][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "query_error_dense"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + vfs_array_uri(fs_vec_[0], temp_dir + "query_error_dense"); + + create_temp_dir(temp_dir); create_dense_array(array_name); @@ -2164,17 +2081,18 @@ TEST_CASE_METHOD( tiledb_array_free(&array); tiledb_query_free(&query); - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + remove_temp_dir(temp_dir); } TEST_CASE_METHOD( ArrayFx, "C API: Test query errors, dense reads in global order", - "[capi][query][error][dense]") { - SupportedFsLocal local_fs; + "[capi][query][error][dense][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "query_error_dense"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + vfs_array_uri(fs_vec_[0], temp_dir + "query_error_dense"); + + create_temp_dir(temp_dir); create_dense_array(array_name); @@ -2216,7 +2134,7 @@ TEST_CASE_METHOD( tiledb_array_free(&array); tiledb_query_free(&query); - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + remove_temp_dir(temp_dir); } TEST_CASE_METHOD( diff --git a/test/src/unit-capi-attributes.cc b/test/src/unit-capi-attributes.cc index 17e61fc3ec2..2c350bc0385 100644 --- a/test/src/unit-capi-attributes.cc +++ b/test/src/unit-capi-attributes.cc @@ -62,12 +62,6 @@ struct Attributesfx { // Vector of supported filesystems const std::vector> fs_vec_; - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - tiledb::test::ServerQueryBuffers server_buffers_; - // Functions Attributesfx(); ~Attributesfx(); @@ -156,7 +150,7 @@ void Attributesfx::create_dense_vector( TEST_CASE_METHOD( Attributesfx, "C API: Test attributes with illegal filesystem characters in the name", - "[capi][attributes][illegal_name]") { + "[capi][attributes][illegal_name][rest]") { const std::vector attr_names = { "miles!hour", "miles#hour", "miles$hour", "miles%hour", "miles&hour", "miles'hour", "miles(hour", "miles)hour", "miles*hour", "miles+hour", @@ -164,25 +158,12 @@ TEST_CASE_METHOD( "miles?hour", "miles@hour", "miles[hour", "miles]hour", "miles[hour", "miles\"hour", "mileshour", "miles\\hour", "miles|hour"}; - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + size_t num = 0; for (const auto& attr_name : attr_names) { for (const auto& fs : fs_vec_) { std::string temp_dir = fs->temp_dir(); - std::string array_name = temp_dir + "array-illegal-char"; - // serialization is not supported for memfs arrays - if (serialize_ && - tiledb::sm::utils::parse::starts_with(array_name, "mem://")) { - continue; - } + std::string array_name = vfs_array_uri( + fs, temp_dir + "array-illegal-char" + std::to_string(num++)); // Create new TileDB context with file lock config disabled, rest the // same. @@ -225,13 +206,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, attr_name.c_str(), buffer_a1, &buffer_a1_size); CHECK(rc == TILEDB_OK); - rc = tiledb::test::submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -259,13 +234,8 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, attr_name.c_str(), buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); + CHECK(rc == TILEDB_OK); // Close array and clean up @@ -280,6 +250,7 @@ TEST_CASE_METHOD( CHECK(buffer_read_size == sizeof(buffer_read_c)); remove_temp_dir(temp_dir); + CHECK(vfs_test_close(fs_vec_, ctx_, vfs_).ok()); } } } @@ -287,27 +258,13 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( Attributesfx, "C API: Test attributes with std::byte", - "[capi][attributes][byte]") { + "[capi][attributes][byte][rest-fails][sc-40489]") { auto datatype = GENERATE(TILEDB_BLOB, TILEDB_GEOM_WKB, TILEDB_GEOM_WKT); - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif for (const auto& fs : fs_vec_) { std::string temp_dir = fs->temp_dir(); - std::string array_name = temp_dir; + std::string array_name = vfs_array_uri(fs, temp_dir + "byte-attribute"); std::string attr_name = "a"; - // serialization is not supported for memfs arrays - if (serialize_ && - tiledb::sm::utils::parse::starts_with(array_name, "mem://")) { - continue; - } // Create new TileDB context with file lock config disabled, rest the // same. @@ -346,13 +303,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, attr_name.c_str(), buffer_write, &buffer_write_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -407,25 +358,25 @@ TEST_CASE_METHOD( ts_open = ts_open + 2; rc = tiledb_array_schema_evolution_set_timestamp_range( ctx_, schema_evolution2, ts_open, ts_open); - if (serialize_) { - // Serialize the array schema evolution - tiledb_buffer_t* buffer; - rc = tiledb_serialize_array_schema_evolution( - ctx_, - schema_evolution2, - (tiledb_serialization_type_t)tiledb::sm::SerializationType::CAPNP, - 0, - &buffer); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_deserialize_array_schema_evolution( - ctx_, - buffer, - (tiledb_serialization_type_t)tiledb::sm::SerializationType::CAPNP, - 1, - &schema_evolution2); - REQUIRE(rc == TILEDB_OK); - tiledb_buffer_free(&buffer); - } +#ifdef TILEDB_SERIALIZATION + // Serialize the array schema evolution + tiledb_buffer_t* buffer; + rc = tiledb_serialize_array_schema_evolution( + ctx_, + schema_evolution2, + (tiledb_serialization_type_t)tiledb::sm::SerializationType::CAPNP, + 0, + &buffer); + REQUIRE(rc == TILEDB_OK); + rc = tiledb_deserialize_array_schema_evolution( + ctx_, + buffer, + (tiledb_serialization_type_t)tiledb::sm::SerializationType::CAPNP, + 1, + &schema_evolution2); + REQUIRE(rc == TILEDB_OK); + tiledb_buffer_free(&buffer); +#endif rc = tiledb_array_evolve(ctx_, array_name.c_str(), schema_evolution2); REQUIRE(rc == TILEDB_OK); @@ -460,14 +411,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, attr_name.c_str(), buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -492,24 +436,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( Attributesfx, "C API: Test attributes with tiledb_bool datatype", - "[capi][attributes][tiledb_bool]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif + "[capi][attributes][tiledb_bool][rest]") { for (const auto& fs : fs_vec_) { std::string temp_dir = fs->temp_dir(); - std::string array_name = temp_dir; - // serialization is not supported for memfs arrays - if (serialize_ && - tiledb::sm::utils::parse::starts_with(array_name, "mem://")) { - continue; - } + std::string array_name = vfs_array_uri(fs, temp_dir + "bool-attribute"); std::string attr_name = "attr"; @@ -554,13 +484,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, attr_name.c_str(), buffer_write, &buffer_write_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up @@ -588,13 +512,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, attr_name.c_str(), buffer_read, &buffer_read_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array and clean up diff --git a/test/src/unit-capi-consolidation.cc b/test/src/unit-capi-consolidation.cc index 19bbe334bc8..1f7527120ec 100644 --- a/test/src/unit-capi-consolidation.cc +++ b/test/src/unit-capi-consolidation.cc @@ -32,6 +32,7 @@ #include #include "test/support/src/helpers.h" +#include "test/support/src/vfs_helpers.h" #include "tiledb/common/stdx_string.h" #include "tiledb/sm/c_api/tiledb.h" #include "tiledb/sm/enums/encryption_type.h" @@ -46,46 +47,32 @@ using namespace tiledb::test; /** Tests for C API consolidation. */ struct ConsolidationFx { - // Constants - const char* DENSE_VECTOR_NAME = "test_consolidate_dense_vector"; - const char* DENSE_VECTOR_FRAG_DIR = - "test_consolidate_dense_vector/__fragments"; - const char* DENSE_VECTOR_FRAG_META_DIR = - "test_consolidate_dense_vector/__fragment_meta"; - const char* DENSE_ARRAY_NAME = "test_consolidate_dense_array"; - const char* DENSE_ARRAY_COMMITS_DIR = - "test_consolidate_dense_array/__commits"; - const char* DENSE_ARRAY_FRAG_DIR = "test_consolidate_dense_array/__fragments"; - const char* SPARSE_ARRAY_NAME = "test_consolidate_sparse_array"; - const char* SPARSE_ARRAY_COMMITS_DIR = - "test_consolidate_sparse_array/__commits"; - const char* SPARSE_ARRAY_FRAG_DIR = - "test_consolidate_sparse_array/__fragments"; - const char* SPARSE_HETEROGENEOUS_ARRAY_NAME = - "test_consolidate_sparse_heterogeneous_array"; - const char* SPARSE_STRING_ARRAY_NAME = "test_consolidate_sparse_string_array"; - const char* SPARSE_STRING_ARRAY_FRAG_DIR = - "test_consolidate_sparse_string_array/__fragments"; - const char* SPARSE_STRING_ARRAY_FRAG_META_DIR = - "test_consolidate_sparse_string_array/__fragment_meta"; + VFSTestSetup vfs_test_setup_; // TileDB context tiledb_ctx_t* ctx_; tiledb_vfs_t* vfs_; + std::string dense_vector_uri_; + std::string dense_vector_frag_dir_; + std::string dense_vector_frag_meta_dir_; + std::string dense_array_uri_; + std::string dense_array_commits_dir_; + std::string dense_array_frag_dir_; + std::string sparse_array_uri_; + std::string sparse_array_commits_dir_; + std::string sparse_array_frag_dir_; + std::string sparse_heterogeneous_array_uri_; + std::string sparse_string_array_uri_; + std::string sparse_string_array_fragment_dir_; + std::string sparse_string_array_frag_meta_dir_; + // Encryption parameters tiledb_encryption_type_t encryption_type_ = TILEDB_NO_ENCRYPTION; const char* encryption_key_ = nullptr; - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - tiledb::test::ServerQueryBuffers server_buffers_; - // Constructors/destructors ConsolidationFx(); - ~ConsolidationFx(); // Functions void create_dense_vector(); @@ -182,16 +169,35 @@ struct ConsolidationFx { static int get_vac_files_callback(const char* path, void* data); }; -ConsolidationFx::ConsolidationFx() { - ctx_ = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx_) == TILEDB_OK); - vfs_ = nullptr; - REQUIRE(tiledb_vfs_alloc(ctx_, nullptr, &vfs_) == TILEDB_OK); -} - -ConsolidationFx::~ConsolidationFx() { - tiledb_ctx_free(&ctx_); - tiledb_vfs_free(&vfs_); +ConsolidationFx::ConsolidationFx() + : ctx_(vfs_test_setup_.ctx_c) + , vfs_(vfs_test_setup_.vfs_c) + , dense_vector_uri_( + vfs_test_setup_.array_uri("test_consolidate_dense_vector")) + , dense_vector_frag_dir_(vfs_test_setup_.array_uri( + "test_consolidate_dense_vector/__fragments", true)) + , dense_vector_frag_meta_dir_(vfs_test_setup_.array_uri( + "test_consolidate_dense_vector/__fragment_meta", true)) + , dense_array_uri_( + vfs_test_setup_.array_uri("test_consolidate_dense_array")) + , dense_array_commits_dir_(vfs_test_setup_.array_uri( + "test_consolidate_dense_array/__commits", true)) + , dense_array_frag_dir_(vfs_test_setup_.array_uri( + "test_consolidate_dense_array/__fragments", true)) + , sparse_array_uri_( + vfs_test_setup_.array_uri("test_consolidate_sparse_array")) + , sparse_array_commits_dir_(vfs_test_setup_.array_uri( + "test_consolidate_sparse_array/__commits", true)) + , sparse_array_frag_dir_(vfs_test_setup_.array_uri( + "test_consolidate_sparse_array/__fragments", true)) + , sparse_heterogeneous_array_uri_(vfs_test_setup_.array_uri( + "test_consolidate_sparse_heterogeneous_array")) + , sparse_string_array_uri_(vfs_test_setup_.array_uri( + "test_consolidate_sparse_string_array", true)) + , sparse_string_array_fragment_dir_(vfs_test_setup_.array_uri( + "test_consolidate_sparse_string_array/__fragments", true)) + , sparse_string_array_frag_meta_dir_(vfs_test_setup_.array_uri( + "test_consolidate_sparse_string_array/__fragment_meta", true)) { } void ConsolidationFx::create_dense_vector() { @@ -234,8 +240,6 @@ void ConsolidationFx::create_dense_vector() { // Create array if (encryption_type_ != TILEDB_NO_ENCRYPTION) { - tiledb_ctx_free(&ctx_); - tiledb_vfs_free(&vfs_); tiledb_config_t* cfg; tiledb_error_t* err = nullptr; rc = tiledb_config_alloc(&cfg, &err); @@ -249,11 +253,13 @@ void ConsolidationFx::create_dense_vector() { rc = tiledb_config_set(cfg, "sm.encryption_key", encryption_key_, &err); REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - REQUIRE(tiledb_ctx_alloc(cfg, &ctx_) == TILEDB_OK); - REQUIRE(tiledb_vfs_alloc(ctx_, cfg, &vfs_) == TILEDB_OK); + // Create new context + vfs_test_setup_.update_config(cfg); + ctx_ = vfs_test_setup_.ctx_c; + vfs_ = vfs_test_setup_.vfs_c; tiledb_config_free(&cfg); } - rc = tiledb_array_create(ctx_, DENSE_VECTOR_NAME, array_schema); + rc = tiledb_array_create(ctx_, dense_vector_uri_.c_str(), array_schema); CHECK(rc == TILEDB_OK); // Clean up @@ -335,8 +341,6 @@ void ConsolidationFx::create_dense_array() { // Create array if (encryption_type_ != TILEDB_NO_ENCRYPTION) { - tiledb_ctx_free(&ctx_); - tiledb_vfs_free(&vfs_); tiledb_config_t* cfg; tiledb_error_t* err = nullptr; rc = tiledb_config_alloc(&cfg, &err); @@ -350,11 +354,13 @@ void ConsolidationFx::create_dense_array() { rc = tiledb_config_set(cfg, "sm.encryption_key", encryption_key_, &err); REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - REQUIRE(tiledb_ctx_alloc(cfg, &ctx_) == TILEDB_OK); - REQUIRE(tiledb_vfs_alloc(ctx_, cfg, &vfs_) == TILEDB_OK); + // Create new context + vfs_test_setup_.update_config(cfg); + ctx_ = vfs_test_setup_.ctx_c; + vfs_ = vfs_test_setup_.vfs_c; tiledb_config_free(&cfg); } - rc = tiledb_array_create(ctx_, DENSE_ARRAY_NAME, array_schema); + rc = tiledb_array_create(ctx_, dense_array_uri_.c_str(), array_schema); CHECK(rc == TILEDB_OK); // Clean up @@ -437,8 +443,6 @@ void ConsolidationFx::create_sparse_array() { // Create array if (encryption_type_ != TILEDB_NO_ENCRYPTION) { - tiledb_ctx_free(&ctx_); - tiledb_vfs_free(&vfs_); tiledb_config_t* cfg; tiledb_error_t* err = nullptr; rc = tiledb_config_alloc(&cfg, &err); @@ -452,11 +456,13 @@ void ConsolidationFx::create_sparse_array() { rc = tiledb_config_set(cfg, "sm.encryption_key", encryption_key_, &err); REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - REQUIRE(tiledb_ctx_alloc(cfg, &ctx_) == TILEDB_OK); - REQUIRE(tiledb_vfs_alloc(ctx_, cfg, &vfs_) == TILEDB_OK); + // Create new context + vfs_test_setup_.update_config(cfg); + ctx_ = vfs_test_setup_.ctx_c; + vfs_ = vfs_test_setup_.vfs_c; tiledb_config_free(&cfg); } - rc = tiledb_array_create(ctx_, SPARSE_ARRAY_NAME, array_schema); + rc = tiledb_array_create(ctx_, sparse_array_uri_.c_str(), array_schema); REQUIRE(rc == TILEDB_OK); // Clean up @@ -541,8 +547,6 @@ void ConsolidationFx::create_sparse_heterogeneous_array() { // Create array if (encryption_type_ != TILEDB_NO_ENCRYPTION) { - tiledb_ctx_free(&ctx_); - tiledb_vfs_free(&vfs_); tiledb_config_t* cfg; tiledb_error_t* err = nullptr; rc = tiledb_config_alloc(&cfg, &err); @@ -556,11 +560,14 @@ void ConsolidationFx::create_sparse_heterogeneous_array() { rc = tiledb_config_set(cfg, "sm.encryption_key", encryption_key_, &err); REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - REQUIRE(tiledb_ctx_alloc(cfg, &ctx_) == TILEDB_OK); - REQUIRE(tiledb_vfs_alloc(ctx_, cfg, &vfs_) == TILEDB_OK); + // Create new context + vfs_test_setup_.update_config(cfg); + ctx_ = vfs_test_setup_.ctx_c; + vfs_ = vfs_test_setup_.vfs_c; tiledb_config_free(&cfg); } - rc = tiledb_array_create(ctx_, SPARSE_HETEROGENEOUS_ARRAY_NAME, array_schema); + rc = tiledb_array_create( + ctx_, sparse_heterogeneous_array_uri_.c_str(), array_schema); REQUIRE(rc == TILEDB_OK); // Clean up @@ -643,8 +650,6 @@ void ConsolidationFx::create_sparse_string_array() { // Create array if (encryption_type_ != TILEDB_NO_ENCRYPTION) { - tiledb_ctx_free(&ctx_); - tiledb_vfs_free(&vfs_); tiledb_config_t* cfg; tiledb_error_t* err = nullptr; rc = tiledb_config_alloc(&cfg, &err); @@ -658,11 +663,14 @@ void ConsolidationFx::create_sparse_string_array() { rc = tiledb_config_set(cfg, "sm.encryption_key", encryption_key_, &err); REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - REQUIRE(tiledb_ctx_alloc(cfg, &ctx_) == TILEDB_OK); - REQUIRE(tiledb_vfs_alloc(ctx_, cfg, &vfs_) == TILEDB_OK); + // Do not remove the array when recreating context to set the new config + vfs_test_setup_.update_config(cfg); + ctx_ = vfs_test_setup_.ctx_c; + vfs_ = vfs_test_setup_.vfs_c; tiledb_config_free(&cfg); } - rc = tiledb_array_create(ctx_, SPARSE_STRING_ARRAY_NAME, array_schema); + rc = + tiledb_array_create(ctx_, sparse_string_array_uri_.c_str(), array_schema); REQUIRE(rc == TILEDB_OK); // Clean up @@ -695,7 +703,7 @@ void ConsolidationFx::write_dense_vector_4_fragments(uint64_t timestamp) { uint64_t a_4_size = sizeof(a_4); tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); tiledb_config_t* cfg; tiledb_error_t* err = nullptr; @@ -892,7 +900,7 @@ void ConsolidationFx::write_dense_vector_4_fragments_not_coinciding() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); REQUIRE(rc == TILEDB_OK); @@ -990,7 +998,7 @@ void ConsolidationFx:: // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); REQUIRE(rc == TILEDB_OK); @@ -1079,7 +1087,7 @@ void ConsolidationFx::write_dense_vector_consolidatable_1() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1169,7 +1177,7 @@ void ConsolidationFx::write_dense_vector_consolidatable_2() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1247,7 +1255,7 @@ void ConsolidationFx::write_dense_vector_del_1() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1355,7 +1363,7 @@ void ConsolidationFx::write_dense_vector_del_2() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1463,7 +1471,7 @@ void ConsolidationFx::write_dense_vector_del_3() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1557,7 +1565,7 @@ void ConsolidationFx::write_dense_vector_del_3() { void ConsolidationFx::write_dense_array_metadata() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); REQUIRE(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1633,7 +1641,7 @@ void ConsolidationFx::write_dense_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1680,13 +1688,7 @@ void ConsolidationFx::write_dense_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -1718,7 +1720,7 @@ void ConsolidationFx::write_dense_subarray( // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1769,13 +1771,7 @@ void ConsolidationFx::write_dense_subarray( CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -1828,7 +1824,7 @@ void ConsolidationFx::write_sparse_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1879,13 +1875,7 @@ void ConsolidationFx::write_sparse_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -1923,7 +1913,7 @@ void ConsolidationFx::write_sparse_unordered() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -1974,13 +1964,7 @@ void ConsolidationFx::write_sparse_unordered() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -2022,7 +2006,7 @@ void ConsolidationFx::write_sparse_row(uint64_t row_idx) { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -2131,7 +2115,8 @@ void ConsolidationFx::write_sparse_heterogeneous_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_HETEROGENEOUS_ARRAY_NAME, &array); + int rc = + tiledb_array_alloc(ctx_, sparse_heterogeneous_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -2182,13 +2167,7 @@ void ConsolidationFx::write_sparse_heterogeneous_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_HETEROGENEOUS_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -2227,7 +2206,8 @@ void ConsolidationFx::write_sparse_heterogeneous_unordered() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_HETEROGENEOUS_ARRAY_NAME, &array); + int rc = + tiledb_array_alloc(ctx_, sparse_heterogeneous_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -2278,13 +2258,7 @@ void ConsolidationFx::write_sparse_heterogeneous_unordered() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_HETEROGENEOUS_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -2342,7 +2316,7 @@ void ConsolidationFx::write_sparse_string_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_STRING_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_string_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -2396,13 +2370,7 @@ void ConsolidationFx::write_sparse_string_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_STRING_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -2444,7 +2412,7 @@ void ConsolidationFx::write_sparse_string_unordered() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_STRING_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_string_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -2498,13 +2466,7 @@ void ConsolidationFx::write_sparse_string_unordered() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_STRING_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Close array rc = tiledb_array_close(ctx_, array); @@ -2518,7 +2480,7 @@ void ConsolidationFx::write_sparse_string_unordered() { void ConsolidationFx::read_dense_array_metadata() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); REQUIRE(rc == TILEDB_OK); tiledb_config_t* cfg; tiledb_error_t* err = nullptr; @@ -2589,7 +2551,7 @@ void ConsolidationFx::read_dense_vector(uint64_t timestamp) { // Set array configuration tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_set_open_timestamp_end(ctx_, array, timestamp); CHECK(rc == TILEDB_OK); @@ -2665,7 +2627,7 @@ void ConsolidationFx::read_dense_vector_with_gaps() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -2734,7 +2696,7 @@ void ConsolidationFx::read_dense_vector_consolidatable_1() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -2806,7 +2768,7 @@ void ConsolidationFx::read_dense_vector_consolidatable_2() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -2874,7 +2836,7 @@ void ConsolidationFx::read_dense_vector_del_1() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -2942,7 +2904,7 @@ void ConsolidationFx::read_dense_vector_del_2() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -3015,7 +2977,7 @@ void ConsolidationFx::read_dense_vector_del_3() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -3097,7 +3059,7 @@ void ConsolidationFx::read_dense_full_subarray() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -3161,14 +3123,7 @@ void ConsolidationFx::read_dense_full_subarray() { CHECK(rc == TILEDB_OK); // Submit query - // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; @@ -3227,7 +3182,7 @@ void ConsolidationFx::read_dense_subarray_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -3291,13 +3246,7 @@ void ConsolidationFx::read_dense_subarray_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Finalize query @@ -3363,7 +3312,7 @@ void ConsolidationFx::read_dense_four_tiles() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -3480,7 +3429,7 @@ void ConsolidationFx::read_sparse_full_unordered() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -3546,13 +3495,7 @@ void ConsolidationFx::read_sparse_full_unordered() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffers @@ -3593,7 +3536,7 @@ void ConsolidationFx::read_sparse_unordered_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -3659,13 +3602,7 @@ void ConsolidationFx::read_sparse_unordered_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffers @@ -3712,7 +3649,7 @@ void ConsolidationFx::read_sparse_rows() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -3823,7 +3760,8 @@ void ConsolidationFx::read_sparse_heterogeneous_full_unordered() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_HETEROGENEOUS_ARRAY_NAME, &array); + int rc = + tiledb_array_alloc(ctx_, sparse_heterogeneous_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -3889,13 +3827,7 @@ void ConsolidationFx::read_sparse_heterogeneous_full_unordered() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_HETEROGENEOUS_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffers @@ -3936,7 +3868,8 @@ void ConsolidationFx::read_sparse_heterogeneous_unordered_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_HETEROGENEOUS_ARRAY_NAME, &array); + int rc = + tiledb_array_alloc(ctx_, sparse_heterogeneous_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -4002,13 +3935,7 @@ void ConsolidationFx::read_sparse_heterogeneous_unordered_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_HETEROGENEOUS_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffers @@ -4051,7 +3978,7 @@ void ConsolidationFx::read_sparse_string_full_unordered() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_STRING_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_string_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -4122,13 +4049,7 @@ void ConsolidationFx::read_sparse_string_full_unordered() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_STRING_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffers @@ -4176,7 +4097,7 @@ void ConsolidationFx::read_sparse_string_unordered_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_STRING_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_string_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); if (encryption_type_ != TILEDB_NO_ENCRYPTION) { tiledb_config_t* cfg; @@ -4247,13 +4168,7 @@ void ConsolidationFx::read_sparse_string_unordered_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_STRING_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffers @@ -4291,7 +4206,8 @@ uint32_t ConsolidationFx::get_num_fragments_to_vacuum_dense() { // Create fragment info object tiledb_fragment_info_t* fragment_info = nullptr; - int rc = tiledb_fragment_info_alloc(ctx_, DENSE_ARRAY_NAME, &fragment_info); + int rc = tiledb_fragment_info_alloc( + ctx_, dense_array_uri_.c_str(), &fragment_info); CHECK(rc == TILEDB_OK); // Load fragment info @@ -4344,7 +4260,7 @@ void ConsolidationFx::consolidate_dense( REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); } - rc = tiledb_array_consolidate(ctx_, DENSE_ARRAY_NAME, cfg); + rc = tiledb_array_consolidate(ctx_, dense_array_uri_.c_str(), cfg); REQUIRE(rc == TILEDB_OK); tiledb_config_free(&cfg); } @@ -4385,7 +4301,7 @@ void ConsolidationFx::consolidate_sparse( REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); } - rc = tiledb_array_consolidate(ctx_, SPARSE_ARRAY_NAME, cfg); + rc = tiledb_array_consolidate(ctx_, sparse_array_uri_.c_str(), cfg); REQUIRE(rc == TILEDB_OK); tiledb_config_free(&cfg); } @@ -4412,10 +4328,12 @@ void ConsolidationFx::consolidate_sparse_heterogeneous() { rc = tiledb_config_set(cfg, "sm.encryption_key", encryption_key_, &err); REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - rc = tiledb_array_consolidate(ctx_, SPARSE_HETEROGENEOUS_ARRAY_NAME, cfg); + rc = tiledb_array_consolidate( + ctx_, sparse_heterogeneous_array_uri_.c_str(), cfg); tiledb_config_free(&cfg); } else { - rc = tiledb_array_consolidate(ctx_, SPARSE_HETEROGENEOUS_ARRAY_NAME, cfg); + rc = tiledb_array_consolidate( + ctx_, sparse_heterogeneous_array_uri_.c_str(), cfg); } tiledb_config_free(&cfg); @@ -4448,10 +4366,10 @@ void ConsolidationFx::consolidate_sparse_string( rc = tiledb_config_set(cfg, "sm.encryption_key", encryption_key_, &err); REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - rc = tiledb_array_consolidate(ctx_, SPARSE_STRING_ARRAY_NAME, cfg); + rc = tiledb_array_consolidate(ctx_, sparse_string_array_uri_.c_str(), cfg); tiledb_config_free(&cfg); } else { - rc = tiledb_array_consolidate(ctx_, SPARSE_STRING_ARRAY_NAME, cfg); + rc = tiledb_array_consolidate(ctx_, sparse_string_array_uri_.c_str(), cfg); } tiledb_config_free(&cfg); @@ -4467,7 +4385,7 @@ void ConsolidationFx::vacuum_dense(const std::string& mode) { rc = tiledb_config_set(cfg, "sm.vacuum.mode", mode.c_str(), &err); REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - rc = tiledb_array_vacuum(ctx_, DENSE_ARRAY_NAME, cfg); + rc = tiledb_array_vacuum(ctx_, dense_array_uri_.c_str(), cfg); REQUIRE(rc == TILEDB_OK); tiledb_config_free(&cfg); @@ -4492,37 +4410,39 @@ void ConsolidationFx::vacuum_sparse( REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - rc = tiledb_array_vacuum(ctx_, SPARSE_ARRAY_NAME, cfg); + rc = tiledb_array_vacuum(ctx_, sparse_array_uri_.c_str(), cfg); REQUIRE(rc == TILEDB_OK); tiledb_config_free(&cfg); } void ConsolidationFx::remove_array(const std::string& array_name) { - if (!is_array(array_name)) - return; + if (!vfs_test_setup_.is_rest()) { + if (!is_array(array_name)) + return; - CHECK(tiledb_object_remove(ctx_, array_name.c_str()) == TILEDB_OK); + CHECK(tiledb_object_remove(ctx_, array_name.c_str()) == TILEDB_OK); + } } void ConsolidationFx::remove_dense_vector() { - remove_array(DENSE_VECTOR_NAME); + remove_array(dense_vector_uri_.c_str()); } void ConsolidationFx::remove_dense_array() { - remove_array(DENSE_ARRAY_NAME); + remove_array(dense_array_uri_.c_str()); } void ConsolidationFx::remove_sparse_array() { - remove_array(SPARSE_ARRAY_NAME); + remove_array(sparse_array_uri_.c_str()); } void ConsolidationFx::remove_sparse_heterogeneous_array() { - remove_array(SPARSE_HETEROGENEOUS_ARRAY_NAME); + remove_array(sparse_heterogeneous_array_uri_.c_str()); } void ConsolidationFx::remove_sparse_string_array() { - remove_array(SPARSE_STRING_ARRAY_NAME); + remove_array(sparse_string_array_uri_.c_str()); } bool ConsolidationFx::is_array(const std::string& array_name) { @@ -4539,20 +4459,21 @@ void ConsolidationFx::check_commits_dir_dense( // Check number of consolidated commits files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, DENSE_ARRAY_COMMITS_DIR, &get_commits_num, &data); + ctx_, vfs_, dense_array_commits_dir_.c_str(), &get_commits_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == num_commits); // Check number of wrt files data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_ARRAY_COMMITS_DIR, &get_wrt_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_array_commits_dir_.c_str(), &get_wrt_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == num_wrt); // Check number of ignore files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, DENSE_ARRAY_COMMITS_DIR, &get_ignore_num, &data); + ctx_, vfs_, dense_array_commits_dir_.c_str(), &get_ignore_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == num_ignore); } @@ -4565,20 +4486,21 @@ void ConsolidationFx::check_commits_dir_sparse( // Check number of consolidated commits files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, SPARSE_ARRAY_COMMITS_DIR, &get_commits_num, &data); + ctx_, vfs_, sparse_array_commits_dir_.c_str(), &get_commits_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == num_commits); // Check number of wrt files data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, SPARSE_ARRAY_COMMITS_DIR, &get_wrt_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, sparse_array_commits_dir_.c_str(), &get_wrt_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == num_wrt); // Check number of ignore files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, SPARSE_ARRAY_COMMITS_DIR, &get_ignore_num, &data); + ctx_, vfs_, sparse_array_commits_dir_.c_str(), &get_ignore_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == num_ignore); } @@ -4589,7 +4511,7 @@ void ConsolidationFx::check_ok_num(int num_ok) { // Check number of ok files data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, SPARSE_ARRAY_NAME, &get_ok_num, &data); + rc = tiledb_vfs_ls(ctx_, vfs_, sparse_array_uri_.c_str(), &get_ok_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == num_ok); } @@ -4597,14 +4519,7 @@ void ConsolidationFx::check_ok_num(int num_ok) { TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, dense", - "[capi][consolidation][dense]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][dense][non-rest]") { remove_dense_array(); create_dense_array(); @@ -4622,18 +4537,15 @@ TEST_CASE_METHOD( read_dense_subarray_full(); } - // Encrypted remote arrays are not supported - if (!serialize_) { - SECTION("- write (encrypted) subarray, full") { - remove_dense_array(); - encryption_type_ = TILEDB_AES_256_GCM; - encryption_key_ = "0123456789abcdeF0123456789abcdeF"; - create_dense_array(); - write_dense_subarray(); - write_dense_full(); - consolidate_dense(); - read_dense_subarray_full(); - } + SECTION("- write (encrypted) subarray, full") { + remove_dense_array(); + encryption_type_ = TILEDB_AES_256_GCM; + encryption_key_ = "0123456789abcdeF0123456789abcdeF"; + create_dense_array(); + write_dense_subarray(); + write_dense_full(); + consolidate_dense(); + read_dense_subarray_full(); } remove_dense_array(); @@ -4642,14 +4554,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, sparse", - "[capi][consolidation][sparse]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][sparse][non-rest]") { remove_sparse_array(); create_sparse_array(); @@ -4667,18 +4572,15 @@ TEST_CASE_METHOD( read_sparse_unordered_full(); } - // Encrypted remote arrays are not supported - if (!serialize_) { - SECTION("- write (encrypted) unordered, full") { - remove_sparse_array(); - encryption_type_ = TILEDB_AES_256_GCM; - encryption_key_ = "0123456789abcdeF0123456789abcdeF"; - create_sparse_array(); - write_sparse_unordered(); - write_sparse_full(); - consolidate_sparse(); - read_sparse_unordered_full(); - } + SECTION("- write (encrypted) unordered, full") { + remove_sparse_array(); + encryption_type_ = TILEDB_AES_256_GCM; + encryption_key_ = "0123456789abcdeF0123456789abcdeF"; + create_sparse_array(); + write_sparse_unordered(); + write_sparse_full(); + consolidate_sparse(); + read_sparse_unordered_full(); } remove_sparse_array(); @@ -4773,7 +4675,7 @@ int ConsolidationFx::get_vac_files_callback(const char* path, void* data) { void ConsolidationFx::get_array_meta_files_dense( std::vector& files) { files.clear(); - tiledb::sm::URI dense_array_uri(DENSE_ARRAY_NAME); + tiledb::sm::URI dense_array_uri(dense_array_uri_.c_str()); int rc = tiledb_vfs_ls( ctx_, vfs_, @@ -4788,7 +4690,7 @@ void ConsolidationFx::get_array_meta_files_dense( void ConsolidationFx::get_array_meta_vac_files_dense( std::vector& files) { files.clear(); - tiledb::sm::URI dense_array_uri(DENSE_ARRAY_NAME); + tiledb::sm::URI dense_array_uri(dense_array_uri_.c_str()); int rc = tiledb_vfs_ls( ctx_, vfs_, @@ -4802,7 +4704,7 @@ void ConsolidationFx::get_array_meta_vac_files_dense( void ConsolidationFx::get_vac_files_dense(std::vector& files) { files.clear(); - tiledb::sm::URI dense_array_uri(DENSE_ARRAY_NAME); + tiledb::sm::URI dense_array_uri(dense_array_uri_.c_str()); int rc = tiledb_vfs_ls( ctx_, vfs_, dense_array_uri.c_str(), &get_vac_files_callback, &files); CHECK(rc == TILEDB_OK); @@ -4812,7 +4714,7 @@ void ConsolidationFx::get_vac_files_dense(std::vector& files) { TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation, wrong configs", - "[capi][consolidation][adv][config]") { + "[capi][consolidation][adv][config][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -4894,7 +4796,7 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Test min frags (currently set to 5) > max frags (currently set to 2) - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_ERR); rc = tiledb_config_set( @@ -4907,13 +4809,13 @@ TEST_CASE_METHOD( config, "sm.consolidation.step_size_ratio", "-1", &error); REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_ERR); rc = tiledb_config_set( config, "sm.consolidation.step_size_ratio", "1.5", &error); REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_ERR); rc = tiledb_config_set( config, "sm.consolidation.step_size_ratio", "0.5", &error); @@ -4925,16 +4827,17 @@ TEST_CASE_METHOD( tiledb_config_set(config, "sm.consolidation.amplification", "-1", &error); REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_ERR); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check that there are 4 fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 4); @@ -4946,7 +4849,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation #1", - "[capi][consolidation][adv][adv-1]") { + "[capi][consolidation][adv][adv-1][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -4980,11 +4883,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -4992,7 +4895,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 3); @@ -5004,7 +4908,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation #2", - "[capi][consolidation][adv][adv-2]") { + "[capi][consolidation][adv][adv-2][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -5038,11 +4942,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5050,7 +4954,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); @@ -5062,7 +4967,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation #3", - "[capi][consolidation][adv][adv-3]") { + "[capi][consolidation][adv][adv-3][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -5096,11 +5001,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5108,7 +5013,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 4); @@ -5120,7 +5026,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation #4", - "[capi][consolidation][adv][adv-4]") { + "[capi][consolidation][adv][adv-4][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -5154,11 +5060,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5166,7 +5072,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 3); @@ -5178,7 +5085,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation #5", - "[capi][consolidation][adv][adv-5]") { + "[capi][consolidation][adv][adv-5][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -5212,11 +5119,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5224,7 +5131,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); @@ -5236,7 +5144,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation #6", - "[capi][consolidation][adv][adv-6]") { + "[capi][consolidation][adv][adv-6][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -5270,11 +5178,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5282,7 +5190,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 1); @@ -5294,7 +5203,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation #7", - "[capi][consolidation][adv][adv-7]") { + "[capi][consolidation][adv][adv-7][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -5328,11 +5237,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5340,7 +5249,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); @@ -5352,7 +5262,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation #8", - "[capi][consolidation][adv][adv-8]") { + "[capi][consolidation][adv][adv-8][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -5386,11 +5296,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5398,7 +5308,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 1); @@ -5413,7 +5324,7 @@ TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, fragments that don't coincide with space tiles " "#1", - "[capi][consolidation][not-coinciding-1]") { + "[capi][consolidation][not-coinciding-1][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments_not_coinciding(); @@ -5447,11 +5358,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5459,7 +5370,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 3); @@ -5475,7 +5387,7 @@ TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, fragments that don't coincide with space tiles " "#2", - "[capi][consolidation][not-coinciding-2]") { + "[capi][consolidation][not-coinciding-2][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments_not_coinciding_with_gaps(); @@ -5513,11 +5425,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5525,7 +5437,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 3); @@ -5536,7 +5449,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation, small buffer size", - "[capi][consolidation][adv][buffer-size]") { + "[capi][consolidation][adv][buffer-size][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -5568,11 +5481,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5580,7 +5493,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); @@ -5591,7 +5505,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation, encrypted array", - "[capi][consolidation][adv][encryption]") { + "[capi][consolidation][adv][encryption][non-rest]") { remove_dense_vector(); encryption_type_ = TILEDB_AES_256_GCM; encryption_key_ = "0123456789abcdeF0123456789abcdeF"; @@ -5631,14 +5545,14 @@ TEST_CASE_METHOD( rc = tiledb_config_set(cfg, "sm.encryption_key", encryption_key_, &err); REQUIRE(rc == TILEDB_OK); REQUIRE(err == nullptr); - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, cfg); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), cfg); CHECK(rc == TILEDB_OK); // Check correctness read_dense_vector(); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5646,7 +5560,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); @@ -5658,7 +5573,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation, overwritten fragments, no deletion", - "[capi][consolidation][adv][overwritten-no-del]") { + "[capi][consolidation][adv][overwritten-no-del][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -5692,11 +5607,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5704,7 +5619,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 4); @@ -5715,7 +5631,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation, overwritten fragments, deletion #1", - "[capi][adv][consolidation][overwritten-del-1]") { + "[capi][adv][consolidation][overwritten-del-1][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_del_1(); @@ -5749,14 +5665,14 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Check correctness read_dense_vector_del_1(); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5764,7 +5680,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); @@ -5775,7 +5692,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation, overwritten fragments, deletion #2", - "[capi][consolidation][adv][overwritten-del-2]") { + "[capi][consolidation][adv][overwritten-del-2][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_del_2(); @@ -5813,11 +5730,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5825,7 +5742,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 1); @@ -5836,7 +5754,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation, overwritten fragments, deletion #3", - "[capi][consolidation][adv][overwritten-del-3]") { + "[capi][consolidation][adv][overwritten-del-3][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_del_3(); @@ -5870,11 +5788,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5882,7 +5800,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); @@ -5896,7 +5815,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation, non-consolidatable", - "[capi][consolidation][adv][non-consolidatable]") { + "[capi][consolidation][adv][non-consolidatable][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_consolidatable_1(); @@ -5930,11 +5849,11 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -5942,7 +5861,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 3); @@ -5954,7 +5874,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test advanced consolidation, consolidatable", - "[capi][consolidation][adv][consolidatable]") { + "[capi][consolidation][adv][consolidatable][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_consolidatable_2(); @@ -6006,7 +5926,7 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Check correctness @@ -6015,12 +5935,13 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == ((should_consolidate) ? 3 : 2)); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check correctness @@ -6028,7 +5949,8 @@ TEST_CASE_METHOD( // Check number of fragments data.num = 0; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == ((should_consolidate) ? 1 : 2)); @@ -6039,7 +5961,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation and time traveling", - "[capi][consolidation][time-traveling]") { + "[capi][consolidation][time-traveling][non-rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -6056,20 +5978,21 @@ TEST_CASE_METHOD( REQUIRE(err == nullptr); // Consolidate - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, cfg); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), cfg); CHECK(rc == TILEDB_OK); tiledb_config_free(&cfg); // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 5); // Check number of consolidated metadata files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, DENSE_VECTOR_FRAG_META_DIR, &get_meta_num, &data); + ctx_, vfs_, dense_vector_frag_meta_dir_.c_str(), &get_meta_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 0); @@ -6080,13 +6003,13 @@ TEST_CASE_METHOD( read_dense_vector(3); read_dense_vector(); - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, NULL); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), NULL); CHECK(rc == TILEDB_OK); read_dense_vector(); // Open array - before timestamp 4, the array will appear empty tiledb_array_t* array; - rc = tiledb_array_alloc(ctx_, DENSE_VECTOR_NAME, &array); + rc = tiledb_array_alloc(ctx_, dense_vector_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_set_open_timestamp_end(ctx_, array, 1); CHECK(rc == TILEDB_OK); @@ -6134,7 +6057,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidating fragment metadata", - "[capi][consolidation][fragment-meta]") { + "[capi][consolidation][fragment-meta][rest]") { remove_dense_vector(); create_dense_vector(); write_dense_vector_4_fragments(); @@ -6150,19 +6073,20 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - this will consolidate only the fragment metadata - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 4); // Check number of consolidated metadata files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, DENSE_VECTOR_FRAG_META_DIR, &get_meta_num, &data); + ctx_, vfs_, dense_vector_frag_meta_dir_.c_str(), &get_meta_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 1); @@ -6176,7 +6100,8 @@ TEST_CASE_METHOD( // Check data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 8); @@ -6190,53 +6115,56 @@ TEST_CASE_METHOD( read_dense_vector(8); // Consolidate - this will consolidate only the fragment metadata - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Check number of consolidated metadata files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, DENSE_VECTOR_FRAG_META_DIR, &get_meta_num, &data); + ctx_, vfs_, dense_vector_frag_meta_dir_.c_str(), &get_meta_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); - // This will vacuum fragments - no effect on consolidated fragment metadata - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, NULL); - CHECK(rc == TILEDB_OK); - CHECK(data.num == 2); - - // Check - data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_VECTOR_FRAG_DIR, &get_dir_num, &data); - CHECK(rc == TILEDB_OK); - CHECK(data.num == 8); - read_dense_vector(1); - read_dense_vector(2); - read_dense_vector(3); - read_dense_vector(4); - read_dense_vector(5); - read_dense_vector(6); - read_dense_vector(7); - read_dense_vector(8); + if (!vfs_test_setup_.is_rest()) { + // This will vacuum fragments - no effect on consolidated fragment metadata + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), NULL); + CHECK(rc == TILEDB_OK); + CHECK(data.num == 2); + + // Check + data = {ctx_, vfs_, 0}; + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_vector_frag_dir_.c_str(), &get_dir_num, &data); + CHECK(rc == TILEDB_OK); + CHECK(data.num == 8); + read_dense_vector(1); + read_dense_vector(2); + read_dense_vector(3); + read_dense_vector(4); + read_dense_vector(5); + read_dense_vector(6); + read_dense_vector(7); + read_dense_vector(8); + } // Test wrong vacuum mode rc = tiledb_config_set(config, "sm.vacuum.mode", "foo", &error); REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_ERR); // Vacuum consolidated fragment metadata rc = tiledb_config_set(config, "sm.vacuum.mode", "fragment_meta", &error); REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - rc = tiledb_array_vacuum(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_vacuum(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Check number of consolidated metadata files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, DENSE_VECTOR_FRAG_META_DIR, &get_meta_num, &data); + ctx_, vfs_, dense_vector_frag_meta_dir_.c_str(), &get_meta_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 1); @@ -6254,7 +6182,7 @@ TEST_CASE_METHOD( rc = tiledb_config_set(config, "sm.consolidation.mode", "foo", &error); REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - rc = tiledb_array_consolidate(ctx_, DENSE_VECTOR_NAME, config); + rc = tiledb_array_consolidate(ctx_, dense_vector_uri_.c_str(), config); CHECK(rc == TILEDB_ERR); tiledb_config_free(&config); @@ -6264,14 +6192,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, sparse heterogeneous", - "[capi][consolidation][sparse][heter]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][sparse][heter][non-rest]") { remove_sparse_heterogeneous_array(); create_sparse_heterogeneous_array(); @@ -6289,18 +6210,15 @@ TEST_CASE_METHOD( read_sparse_heterogeneous_unordered_full(); } - // Encrypted remote arrays are not supported - if (!serialize_) { - SECTION("- write (encrypted) unordered, full") { - remove_sparse_heterogeneous_array(); - encryption_type_ = TILEDB_AES_256_GCM; - encryption_key_ = "0123456789abcdeF0123456789abcdeF"; - create_sparse_heterogeneous_array(); - write_sparse_heterogeneous_unordered(); - write_sparse_heterogeneous_full(); - consolidate_sparse_heterogeneous(); - read_sparse_heterogeneous_unordered_full(); - } + SECTION("- write (encrypted) unordered, full") { + remove_sparse_heterogeneous_array(); + encryption_type_ = TILEDB_AES_256_GCM; + encryption_key_ = "0123456789abcdeF0123456789abcdeF"; + create_sparse_heterogeneous_array(); + write_sparse_heterogeneous_unordered(); + write_sparse_heterogeneous_full(); + consolidate_sparse_heterogeneous(); + read_sparse_heterogeneous_unordered_full(); } remove_sparse_heterogeneous_array(); @@ -6309,14 +6227,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, sparse string", - "[capi][consolidation][sparse][string]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][sparse][string][non-rest]") { remove_sparse_string_array(); create_sparse_string_array(); @@ -6334,18 +6245,15 @@ TEST_CASE_METHOD( read_sparse_string_unordered_full(); } - // Encrypted remote arrays are not supported - if (!serialize_) { - SECTION("- write (encrypted) unordered, full") { - remove_sparse_string_array(); - encryption_type_ = TILEDB_AES_256_GCM; - encryption_key_ = "0123456789abcdeF0123456789abcdeF"; - create_sparse_string_array(); - write_sparse_string_unordered(); - write_sparse_string_full(); - consolidate_sparse_string(); - read_sparse_string_unordered_full(); - } + SECTION("- write (encrypted) unordered, full") { + remove_sparse_string_array(); + encryption_type_ = TILEDB_AES_256_GCM; + encryption_key_ = "0123456789abcdeF0123456789abcdeF"; + create_sparse_string_array(); + write_sparse_string_unordered(); + write_sparse_string_full(); + consolidate_sparse_string(); + read_sparse_string_unordered_full(); } remove_sparse_string_array(); @@ -6354,14 +6262,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidating fragment metadata, sparse string", - "[capi][consolidation][fragment-meta][sparse][string]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][fragment-meta][sparse][string][rest]") { remove_sparse_string_array(); create_sparse_string_array(); write_sparse_string_full(); @@ -6381,20 +6282,28 @@ TEST_CASE_METHOD( REQUIRE(error == nullptr); // Consolidate - this will consolidate only the fragment metadata - rc = tiledb_array_consolidate(ctx_, SPARSE_STRING_ARRAY_NAME, config); + rc = tiledb_array_consolidate(ctx_, sparse_string_array_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, SPARSE_STRING_ARRAY_FRAG_DIR, &get_dir_num, &data); + ctx_, + vfs_, + sparse_string_array_fragment_dir_.c_str(), + &get_dir_num, + &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); // Check number of consolidated metadata files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, SPARSE_STRING_ARRAY_FRAG_META_DIR, &get_meta_num, &data); + ctx_, + vfs_, + sparse_string_array_frag_meta_dir_.c_str(), + &get_meta_num, + &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 1); @@ -6405,13 +6314,17 @@ TEST_CASE_METHOD( rc = tiledb_config_set(config, "sm.vacuum.mode", "fragment_meta", &error); REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - rc = tiledb_array_vacuum(ctx_, SPARSE_STRING_ARRAY_NAME, config); + rc = tiledb_array_vacuum(ctx_, sparse_string_array_uri_.c_str(), config); CHECK(rc == TILEDB_OK); // Check number of consolidated metadata files data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx_, vfs_, SPARSE_STRING_ARRAY_FRAG_META_DIR, &get_meta_num, &data); + ctx_, + vfs_, + sparse_string_array_frag_meta_dir_.c_str(), + &get_meta_num, + &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 1); @@ -6426,14 +6339,7 @@ TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidating fragment metadata, sparse string, pass only " "context", - "[capi][consolidation][fragment-meta][sparse][string]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][fragment-meta][sparse][string][non-rest]") { remove_sparse_string_array(); create_sparse_string_array(); write_sparse_string_full(); @@ -6452,24 +6358,34 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); + vfs_test_setup_.update_config(config); + ctx_ = vfs_test_setup_.ctx_c; + vfs_ = vfs_test_setup_.vfs_c; // Consolidate - this will consolidate only the fragment metadata - rc = tiledb_array_consolidate(ctx, SPARSE_STRING_ARRAY_NAME, nullptr); + rc = + tiledb_array_consolidate(ctx_, sparse_string_array_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check number of fragments - get_num_struct data = {ctx, vfs_, 0}; + get_num_struct data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx, vfs_, SPARSE_STRING_ARRAY_FRAG_DIR, &get_dir_num, &data); + ctx_, + vfs_, + sparse_string_array_fragment_dir_.c_str(), + &get_dir_num, + &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 2); // Check number of consolidated metadata files - data = {ctx, vfs_, 0}; + data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx, vfs_, SPARSE_STRING_ARRAY_FRAG_META_DIR, &get_meta_num, &data); + ctx_, + vfs_, + sparse_string_array_frag_meta_dir_.c_str(), + &get_meta_num, + &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 1); @@ -6481,24 +6397,27 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - // Create new context - tiledb_ctx_free(&ctx); - REQUIRE(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); + vfs_test_setup_.update_config(config); + ctx_ = vfs_test_setup_.ctx_c; + vfs_ = vfs_test_setup_.vfs_c; - rc = tiledb_array_vacuum(ctx, SPARSE_STRING_ARRAY_NAME, nullptr); + rc = tiledb_array_vacuum(ctx_, sparse_string_array_uri_.c_str(), nullptr); CHECK(rc == TILEDB_OK); // Check number of consolidated metadata files - data = {ctx, vfs_, 0}; + data = {ctx_, vfs_, 0}; rc = tiledb_vfs_ls( - ctx, vfs_, SPARSE_STRING_ARRAY_FRAG_META_DIR, &get_meta_num, &data); + ctx_, + vfs_, + sparse_string_array_frag_meta_dir_.c_str(), + &get_meta_num, + &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 1); // Validate read read_sparse_string_full_unordered(); - tiledb_ctx_free(&ctx); tiledb_config_free(&config); remove_sparse_string_array(); } @@ -6506,14 +6425,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation and timestamps", - "[capi][consolidation][timestamps]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][timestamps][non-rest]") { remove_dense_array(); create_dense_array(); @@ -6585,14 +6497,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test vacuuming and timestamps", - "[capi][vacuuming][timestamps]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][vacuuming][timestamps][non-rest]") { remove_dense_array(); create_dense_array(); @@ -6656,14 +6561,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, dense, commits", - "[capi][consolidation][dense][commits]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][dense][commits][rest]") { remove_dense_array(); create_dense_array(); @@ -6691,20 +6589,23 @@ TEST_CASE_METHOD( check_commits_dir_dense(1, 0, 0); // After fragment consolidation and vacuuming, array is still valid. - consolidate_dense(); - vacuum_dense(); - read_dense_full_subarray(); - check_commits_dir_dense(1, 1, 1); + // Fragment consolidation not yet supported on remote arrays + if (!vfs_test_setup_.is_rest()) { + consolidate_dense(); + vacuum_dense(); + read_dense_full_subarray(); + check_commits_dir_dense(1, 1, 1); - // Consolidation to get rid of ignore file. - consolidate_dense("commits"); - read_dense_full_subarray(); - check_commits_dir_dense(2, 1, 1); + // Consolidation to get rid of ignore file. + consolidate_dense("commits"); + read_dense_full_subarray(); + check_commits_dir_dense(2, 1, 1); - // Second vacuum works. - vacuum_dense("commits"); - read_dense_full_subarray(); - check_commits_dir_dense(1, 0, 0); + // Second vacuum works. + vacuum_dense("commits"); + read_dense_full_subarray(); + check_commits_dir_dense(1, 0, 0); + } } SECTION("- write subarray, full") { @@ -6730,24 +6631,26 @@ TEST_CASE_METHOD( check_commits_dir_dense(1, 0, 0); // After fragment consolidation and vacuuming, array is still valid. - consolidate_dense(); - vacuum_dense(); - read_dense_subarray_full(); - check_commits_dir_dense(1, 1, 1); + // Fragment consolidation not yet supported on remote arrays + if (!vfs_test_setup_.is_rest()) { + consolidate_dense(); + vacuum_dense(); + read_dense_subarray_full(); + check_commits_dir_dense(1, 1, 1); - // Consolidation to get rid of ignore file. - consolidate_dense("commits"); - read_dense_subarray_full(); - check_commits_dir_dense(2, 1, 1); + // Consolidation to get rid of ignore file. + consolidate_dense("commits"); + read_dense_subarray_full(); + check_commits_dir_dense(2, 1, 1); - // Second vacuum works. - vacuum_dense("commits"); - read_dense_subarray_full(); - check_commits_dir_dense(1, 0, 0); + // Second vacuum works. + vacuum_dense("commits"); + read_dense_subarray_full(); + check_commits_dir_dense(1, 0, 0); + } } - // Encrypted remote arrays are not supported - if (!serialize_) { + if (!vfs_test_setup_.is_rest()) { SECTION("- write (encrypted) subarray, full") { remove_dense_array(); encryption_type_ = TILEDB_AES_256_GCM; @@ -6799,14 +6702,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, sparse, commits", - "[capi][consolidation][sparse][commits]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][sparse][commits][rest]") { remove_sparse_array(); create_sparse_array(); @@ -6834,20 +6730,23 @@ TEST_CASE_METHOD( check_commits_dir_sparse(1, 0, 0); // After fragment consolidation and vacuuming, array is still valid. - consolidate_sparse(); - vacuum_sparse(); - read_sparse_full_unordered(); - check_commits_dir_sparse(1, 1, 1); + // Fragment consolidation not yet supported on remote arrays + if (!vfs_test_setup_.is_rest()) { + consolidate_sparse(); + vacuum_sparse(); + read_sparse_full_unordered(); + check_commits_dir_sparse(1, 1, 1); - // Consolidation to get rid of ignore file. - consolidate_sparse("commits"); - read_sparse_full_unordered(); - check_commits_dir_sparse(2, 1, 1); + // Consolidation to get rid of ignore file. + consolidate_sparse("commits"); + read_sparse_full_unordered(); + check_commits_dir_sparse(2, 1, 1); - // Second vacuum works. - vacuum_sparse("commits"); - read_sparse_full_unordered(); - check_commits_dir_sparse(1, 0, 0); + // Second vacuum works. + vacuum_sparse("commits"); + read_sparse_full_unordered(); + check_commits_dir_sparse(1, 0, 0); + } } SECTION("- write unordered, full") { @@ -6874,24 +6773,26 @@ TEST_CASE_METHOD( check_commits_dir_sparse(1, 0, 0); // After fragment consolidation and vacuuming, array is still valid. - consolidate_sparse(); - vacuum_sparse(); - read_sparse_unordered_full(); - check_commits_dir_sparse(1, 1, 1); + // Fragment consolidation not yet supported on remote arrays + if (!vfs_test_setup_.is_rest()) { + consolidate_sparse(); + vacuum_sparse(); + read_sparse_unordered_full(); + check_commits_dir_sparse(1, 1, 1); - // Consolidation to get rid of ignore file. - consolidate_sparse("commits"); - read_sparse_unordered_full(); - check_commits_dir_sparse(2, 1, 1); + // Consolidation to get rid of ignore file. + consolidate_sparse("commits"); + read_sparse_unordered_full(); + check_commits_dir_sparse(2, 1, 1); - // Second vacuum works. - vacuum_sparse("commits"); - read_sparse_unordered_full(); - check_commits_dir_sparse(1, 0, 0); + // Second vacuum works. + vacuum_sparse("commits"); + read_sparse_unordered_full(); + check_commits_dir_sparse(1, 0, 0); + } } - // Encrypted remote arrays are not supported - if (!serialize_) { + if (!vfs_test_setup_.is_rest()) { SECTION("- write (encrypted) unordered, full") { remove_sparse_array(); encryption_type_ = TILEDB_AES_256_GCM; @@ -6946,17 +6847,14 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, sparse, commits, mixed versions", - "[capi][consolidation][commits][mixed-versions]") { + "[capi][consolidation][commits][mixed-versions][non-rest]") { if constexpr (is_experimental_build) { return; } -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); + if (!vfs_test_setup_.is_local()) { + return; } -#endif remove_sparse_array(); @@ -6965,14 +6863,15 @@ TEST_CASE_METHOD( std::string(TILEDB_TEST_INPUTS_DIR) + "/arrays/sparse_array_v11"; REQUIRE( tiledb_vfs_copy_dir( - ctx_, vfs_, v11_arrays_dir.c_str(), SPARSE_ARRAY_NAME) == TILEDB_OK); + ctx_, vfs_, v11_arrays_dir.c_str(), sparse_array_uri_.c_str()) == + TILEDB_OK); // Write v11 fragment. write_sparse_full(); // Upgrade to latest version. REQUIRE( - tiledb_array_upgrade_version(ctx_, SPARSE_ARRAY_NAME, nullptr) == + tiledb_array_upgrade_version(ctx_, sparse_array_uri_.c_str(), nullptr) == TILEDB_OK); // Consolidation works. @@ -7021,14 +6920,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, dense split fragments", - "[capi][consolidation][dense][split-fragments]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][dense][split-fragments][non-rest]") { remove_dense_array(); create_dense_array(); write_dense_subarray(1, 2, 1, 2); @@ -7038,7 +6930,8 @@ TEST_CASE_METHOD( // Create fragment info object tiledb_fragment_info_t* fragment_info = nullptr; - int rc = tiledb_fragment_info_alloc(ctx_, DENSE_ARRAY_NAME, &fragment_info); + int rc = tiledb_fragment_info_alloc( + ctx_, dense_array_uri_.c_str(), &fragment_info); CHECK(rc == TILEDB_OK); // Load fragment info @@ -7067,7 +6960,8 @@ TEST_CASE_METHOD( // Consolidate const char* uris[2] = {strrchr(uri1, '/') + 1, strrchr(uri2, '/') + 1}; - rc = tiledb_array_consolidate_fragments(ctx_, DENSE_ARRAY_NAME, uris, 2, cfg); + rc = tiledb_array_consolidate_fragments( + ctx_, dense_array_uri_.c_str(), uris, 2, cfg); CHECK(rc == TILEDB_OK); tiledb_config_free(&cfg); @@ -7075,7 +6969,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_ARRAY_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_array_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 5); @@ -7083,13 +6978,14 @@ TEST_CASE_METHOD( read_dense_four_tiles(); // Vacuum - rc = tiledb_array_vacuum(ctx_, DENSE_ARRAY_NAME, NULL); + rc = tiledb_array_vacuum(ctx_, dense_array_uri_.c_str(), NULL); CHECK(rc == TILEDB_OK); read_dense_four_tiles(); // Check number of fragments data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, DENSE_ARRAY_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, dense_array_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 3); @@ -7100,7 +6996,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, sparse split fragments", - "[capi][consolidation][sparse][split-fragments]") { + "[capi][consolidation][sparse][split-fragments][non-rest]") { remove_sparse_array(); create_sparse_array(); write_sparse_row(0); @@ -7110,7 +7006,8 @@ TEST_CASE_METHOD( // Create fragment info object tiledb_fragment_info_t* fragment_info = nullptr; - int rc = tiledb_fragment_info_alloc(ctx_, SPARSE_ARRAY_NAME, &fragment_info); + int rc = tiledb_fragment_info_alloc( + ctx_, sparse_array_uri_.c_str(), &fragment_info); CHECK(rc == TILEDB_OK); // Load fragment info @@ -7139,8 +7036,8 @@ TEST_CASE_METHOD( // Consolidate const char* uris[2] = {strrchr(uri1, '/') + 1, strrchr(uri2, '/') + 1}; - rc = - tiledb_array_consolidate_fragments(ctx_, SPARSE_ARRAY_NAME, uris, 2, cfg); + rc = tiledb_array_consolidate_fragments( + ctx_, sparse_array_uri_.c_str(), uris, 2, cfg); CHECK(rc == TILEDB_OK); tiledb_config_free(&cfg); @@ -7148,7 +7045,8 @@ TEST_CASE_METHOD( // Check number of fragments get_num_struct data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, SPARSE_ARRAY_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, sparse_array_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 5); @@ -7156,13 +7054,14 @@ TEST_CASE_METHOD( read_sparse_rows(); // Vacuum - rc = tiledb_array_vacuum(ctx_, SPARSE_ARRAY_NAME, NULL); + rc = tiledb_array_vacuum(ctx_, sparse_array_uri_.c_str(), NULL); CHECK(rc == TILEDB_OK); read_sparse_rows(); // Check number of fragments data = {ctx_, vfs_, 0}; - rc = tiledb_vfs_ls(ctx_, vfs_, SPARSE_ARRAY_FRAG_DIR, &get_dir_num, &data); + rc = tiledb_vfs_ls( + ctx_, vfs_, sparse_array_frag_dir_.c_str(), &get_dir_num, &data); CHECK(rc == TILEDB_OK); CHECK(data.num == 3); @@ -7173,7 +7072,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, empty array", - "[capi][consolidation][empty]") { + "[capi][consolidation][empty][non-rest]") { auto sparse = GENERATE(true, false); auto mode = GENERATE( std::string("commits"), @@ -7199,7 +7098,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, sparse string, no progress", - "[capi][consolidation][sparse][string][no-progress]") { + "[capi][consolidation][sparse][string][no-progress][non-rest]") { remove_sparse_string_array(); create_sparse_string_array(); @@ -7222,14 +7121,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationFx, "C API: Test consolidation, fragments/commits out of order", - "[capi][consolidation][fragments-commits][out-of-order]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][consolidation][fragments-commits][out-of-order][non-rest]") { remove_sparse_array(); create_sparse_array(); diff --git a/test/src/unit-capi-dense_array.cc b/test/src/unit-capi-dense_array.cc index ce94c7f7c35..6c0249be287 100644 --- a/test/src/unit-capi-dense_array.cc +++ b/test/src/unit-capi-dense_array.cc @@ -37,7 +37,6 @@ #include #include "test/support/src/helpers.h" -#include "test/support/src/serialization_wrappers.h" #include "test/support/src/vfs_helpers.h" #ifdef _WIN32 #include "tiledb/sm/filesystem/win.h" @@ -104,24 +103,21 @@ struct DenseArrayFx { // Vector of supported filsystems const std::vector> fs_vec_; - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; + // Path to prepend to array name according to filesystem/mode + std::string prefix_; // Functions DenseArrayFx(); ~DenseArrayFx(); void create_temp_dir(const std::string& path); void remove_temp_dir(const std::string& path); - void check_sorted_reads(const std::string& path); - void check_sorted_writes(const std::string& path); - void check_invalid_cell_num_in_dense_writes(const std::string& path); - void check_simultaneous_writes(const std::string& path); - void check_cancel_and_retry_writes(const std::string& path); - void check_return_coords(const std::string& path, bool split_coords); - void check_non_empty_domain(const std::string& path); + void check_sorted_reads(); + void check_sorted_writes(); + void check_invalid_cell_num_in_dense_writes(); + void check_simultaneous_writes(); + void check_cancel_and_retry_writes(); + void check_return_coords(bool split_coords); + void check_non_empty_domain(); void create_dense_vector(const std::string& path); void create_dense_array(const std::string& array_name); void create_dense_array_1_attribute(const std::string& array_name); @@ -265,7 +261,8 @@ struct DenseArrayFx { }; DenseArrayFx::DenseArrayFx() - : fs_vec_(vfs_test_get_fs_vec()) { + : fs_vec_(vfs_test_get_fs_vec()) + , prefix_(vfs_array_uri(fs_vec_[0], fs_vec_[0]->temp_dir())) { // Initialize vfs test REQUIRE(vfs_test_init(fs_vec_, &ctx_, &vfs_).ok()); std::srand(0); @@ -510,8 +507,7 @@ int* DenseArrayFx::read_dense_array_2D( REQUIRE(rc == TILEDB_OK); tiledb_config_free(&cfg); } - rc = array_open_wrapper( - ctx_, query_type, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, query_type); CHECK(rc == TILEDB_OK); // Create query @@ -533,13 +529,7 @@ int* DenseArrayFx::read_dense_array_2D( CHECK(!has_results); // Read from array - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Now the query must have results @@ -547,6 +537,12 @@ int* DenseArrayFx::read_dense_array_2D( CHECK(rc == TILEDB_OK); CHECK(has_results); + rc = tiledb_query_finalize(ctx_, query); + REQUIRE(rc == TILEDB_OK); + rc = + tiledb_query_finalize(ctx_, query); // Second time must create no problem + REQUIRE(rc == TILEDB_OK); + // Close array rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -604,9 +600,8 @@ void DenseArrayFx::write_dense_vector_mixed(const std::string& array_name) { REQUIRE(rc == TILEDB_OK); tiledb_config_free(&cfg); } - rc = array_open_wrapper( - ctx_, TILEDB_WRITE, (serialize_ && refactored_query_v2_), &array); - CHECK(rc == TILEDB_OK); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); + REQUIRE(rc == TILEDB_OK); // Submit query #1 - Dense tiledb_query_t* query_1; @@ -619,13 +614,7 @@ void DenseArrayFx::write_dense_vector_mixed(const std::string& array_name) { CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query_1, "a", a_1, &a_1_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query_1, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query_1); CHECK(rc == TILEDB_OK); tiledb_query_free(&query_1); @@ -640,13 +629,7 @@ void DenseArrayFx::write_dense_vector_mixed(const std::string& array_name) { rc = tiledb_query_set_data_buffer( ctx_, query_2, "d", coords_2, &coords_2_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query_2, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query_2); CHECK(rc == TILEDB_OK); tiledb_query_free(&query_2); @@ -661,13 +644,7 @@ void DenseArrayFx::write_dense_vector_mixed(const std::string& array_name) { rc = tiledb_query_set_data_buffer( ctx_, query_3, "d", coords_3, &coords_3_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query_3, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query_3); CHECK(rc == TILEDB_OK); tiledb_query_free(&query_3); @@ -683,13 +660,7 @@ void DenseArrayFx::write_dense_vector_mixed(const std::string& array_name) { CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query_4, "a", a_4, &a_4_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query_4, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query_4); CHECK(rc == TILEDB_OK); tiledb_query_free(&query_4); @@ -743,8 +714,7 @@ void DenseArrayFx::write_dense_array_by_tiles( REQUIRE(rc == TILEDB_OK); tiledb_config_free(&cfg); } - rc = array_open_wrapper( - ctx_, TILEDB_WRITE, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create query @@ -776,7 +746,12 @@ void DenseArrayFx::write_dense_array_by_tiles( buffer_size = k * l * sizeof(int); buffer_sizes[0] = buffer_size; - auto rc{tiledb_query_submit(ctx_, query)}; + if ((i == domain_size_0 - tile_extent_0) && + (j == domain_size_1 - tile_extent_1)) { + rc = tiledb_query_submit_and_finalize(ctx_, query); + } else { + rc = tiledb_query_submit(ctx_, query); + } const char* msg = "unset"; tiledb_error_t* err{nullptr}; @@ -790,10 +765,6 @@ void DenseArrayFx::write_dense_array_by_tiles( } } - // Finalize query - rc = tiledb_query_finalize(ctx_, query); - REQUIRE(rc == TILEDB_OK); - // Close array rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -822,9 +793,8 @@ void DenseArrayFx::write_dense_subarray_2D( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK_SAFE(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_WRITE, (serialize_ && refactored_query_v2_), &array); - CHECK(rc == TILEDB_OK); + rc = tiledb_array_open(ctx_, array, query_type); + CHECK_SAFE(rc == TILEDB_OK); // Create query tiledb_query_t* query; @@ -839,13 +809,13 @@ void DenseArrayFx::write_dense_subarray_2D( REQUIRE_SAFE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + if (query_layout != TILEDB_GLOBAL_ORDER) { + rc = tiledb_query_submit(ctx_, query); + REQUIRE_SAFE(rc == TILEDB_OK); + rc = tiledb_query_finalize(ctx_, query); + } else { + tiledb_query_submit_and_finalize(ctx_, query); + } REQUIRE_SAFE(rc == TILEDB_OK); // Close array @@ -873,8 +843,7 @@ void DenseArrayFx::write_dense_subarray_2D_with_cancel( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_WRITE, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, query_type); CHECK(rc == TILEDB_OK); // Create query @@ -957,7 +926,7 @@ void DenseArrayFx::write_dense_subarray_2D_with_cancel( tiledb_query_free(&query); } -void DenseArrayFx::check_sorted_reads(const std::string& path) { +void DenseArrayFx::check_sorted_reads() { // Parameters used in this test int64_t domain_size_0 = 2500; int64_t domain_size_1 = 5000; @@ -970,7 +939,7 @@ void DenseArrayFx::check_sorted_reads(const std::string& path) { uint64_t capacity = 250000; tiledb_layout_t cell_order = TILEDB_ROW_MAJOR; tiledb_layout_t tile_order = TILEDB_ROW_MAJOR; - std::string array_name = path + "sorted_reads_array"; + std::string array_name = prefix_ + "sorted_reads_array"; // Create a dense integer array create_dense_array_2D( @@ -1056,8 +1025,7 @@ void DenseArrayFx::check_sorted_reads(const std::string& path) { REQUIRE(rc == TILEDB_OK); tiledb_config_free(&cfg); } - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Check out of bounds subarray @@ -1105,7 +1073,7 @@ void DenseArrayFx::check_sorted_reads(const std::string& path) { tiledb_query_free(&query); } -void DenseArrayFx::check_sorted_writes(const std::string& path) { +void DenseArrayFx::check_sorted_writes() { // Parameters used in this test int64_t domain_size_0 = 100; int64_t domain_size_1 = 100; @@ -1118,7 +1086,7 @@ void DenseArrayFx::check_sorted_writes(const std::string& path) { uint64_t capacity = 1000; tiledb_layout_t cell_order = TILEDB_ROW_MAJOR; tiledb_layout_t tile_order = TILEDB_ROW_MAJOR; - std::string array_name = path + "sorted_writes_array"; + std::string array_name = prefix_ + "sorted_writes_array"; // Create a dense integer array create_dense_array_2D( @@ -1190,8 +1158,7 @@ void DenseArrayFx::check_sorted_writes(const std::string& path) { } } -void DenseArrayFx::check_invalid_cell_num_in_dense_writes( - const std::string& path) { +void DenseArrayFx::check_invalid_cell_num_in_dense_writes() { // Parameters used in this test int64_t domain_size_0 = 100; int64_t domain_size_1 = 100; @@ -1204,7 +1171,7 @@ void DenseArrayFx::check_invalid_cell_num_in_dense_writes( uint64_t capacity = 1000; tiledb_layout_t cell_order = TILEDB_ROW_MAJOR; tiledb_layout_t tile_order = TILEDB_ROW_MAJOR; - std::string array_name = path + "invalid_cell_num_dense_writes_array"; + std::string array_name = prefix_ + "invalid_cell_num_dense_writes_array"; // Create a dense integer array create_dense_array_2D( @@ -1228,8 +1195,7 @@ void DenseArrayFx::check_invalid_cell_num_in_dense_writes( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_WRITE, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Global order @@ -1241,9 +1207,7 @@ void DenseArrayFx::check_invalid_cell_num_in_dense_writes( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx_, query); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx_, query); + rc = tiledb_query_submit_and_finalize(ctx_, query); REQUIRE(rc == TILEDB_ERR); tiledb_query_free(&query); @@ -1255,13 +1219,7 @@ void DenseArrayFx::check_invalid_cell_num_in_dense_writes( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_ERR); tiledb_query_free(&query); @@ -1273,7 +1231,7 @@ void DenseArrayFx::check_invalid_cell_num_in_dense_writes( tiledb_array_free(&array); } -void DenseArrayFx::check_simultaneous_writes(const std::string& path) { +void DenseArrayFx::check_simultaneous_writes() { // Parameters used in this test int64_t domain_size_0 = 100; int64_t domain_size_1 = 100; @@ -1286,7 +1244,7 @@ void DenseArrayFx::check_simultaneous_writes(const std::string& path) { uint64_t capacity = 1000; tiledb_layout_t cell_order = TILEDB_ROW_MAJOR; tiledb_layout_t tile_order = TILEDB_ROW_MAJOR; - std::string array_name = path + "simultaneous_writes_array"; + std::string array_name = prefix_ + "simultaneous_writes_array"; // Create a dense integer array create_dense_array_2D( @@ -1343,7 +1301,7 @@ void DenseArrayFx::check_simultaneous_writes(const std::string& path) { } } -void DenseArrayFx::check_cancel_and_retry_writes(const std::string& path) { +void DenseArrayFx::check_cancel_and_retry_writes() { // Parameters used in this test int64_t domain_size_0 = 100; int64_t domain_size_1 = 100; @@ -1356,7 +1314,7 @@ void DenseArrayFx::check_cancel_and_retry_writes(const std::string& path) { uint64_t capacity = 1000; tiledb_layout_t cell_order = TILEDB_ROW_MAJOR; tiledb_layout_t tile_order = TILEDB_ROW_MAJOR; - std::string array_name = path + "cancel_and_retry_writes_array"; + std::string array_name = prefix_ + "cancel_and_retry_writes_array"; // Create a dense integer array create_dense_array_2D( @@ -1682,9 +1640,8 @@ void DenseArrayFx::create_large_dense_array_1_attribute( tiledb_array_schema_free(&array_schema); } -void DenseArrayFx::check_return_coords( - const std::string& path, bool split_coords) { - std::string array_name = path + "return_coords"; +void DenseArrayFx::check_return_coords(bool split_coords) { + std::string array_name = prefix_ + "return_coords"; create_dense_array(array_name); write_dense_array(array_name); read_dense_array_with_coords_full_global(array_name, split_coords); @@ -1734,8 +1691,7 @@ void DenseArrayFx::write_dense_array(const std::string& array_name) { tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_WRITE, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create query @@ -1756,14 +1712,7 @@ void DenseArrayFx::write_dense_array(const std::string& array_name) { rc = tiledb_query_set_data_buffer( ctx_, query, attributes[2], buffers[3], &buffer_sizes[3]); CHECK(rc == TILEDB_OK); - - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -1815,8 +1764,7 @@ void DenseArrayFx::write_dense_array_missing_attributes( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_WRITE, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create query @@ -1838,13 +1786,7 @@ void DenseArrayFx::write_dense_array_missing_attributes( // Observe we omit setting buffer for one of the attributes (a3) // Submit query - this should fail - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_ERR); // Close array @@ -1880,8 +1822,7 @@ void DenseArrayFx::write_partial_dense_array(const std::string& array_name) { tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_WRITE, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create query @@ -1906,13 +1847,7 @@ void DenseArrayFx::write_partial_dense_array(const std::string& array_name) { rc = tiledb_query_set_subarray(ctx_, query, subarray); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -1970,13 +1905,10 @@ void DenseArrayFx::write_large_dense_array(const std::string& array_name) { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); + CHECK(rc == TILEDB_OK); + // Finalize query + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -2024,9 +1956,8 @@ void DenseArrayFx::read_dense_vector_mixed(const std::string& array_name) { REQUIRE(rc == TILEDB_OK); tiledb_config_free(&cfg); } - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); - CHECK(rc == TILEDB_OK); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); + REQUIRE(rc == TILEDB_OK); // Preparation uint64_t subarray[] = {1, 410}; @@ -2043,19 +1974,17 @@ void DenseArrayFx::read_dense_vector_mixed(const std::string& array_name) { CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query, "a", a, &a_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); CHECK(status == TILEDB_COMPLETED); + // Finalize query + rc = tiledb_query_finalize(ctx_, query); + CHECK(rc == TILEDB_OK); + // Check buffers CHECK(sizeof(c_a) == a_size); for (int i = 0; i < 410; ++i) @@ -2098,8 +2027,7 @@ void DenseArrayFx::read_dense_array_with_coords_full_global( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Compute max buffer sizes @@ -2160,19 +2088,17 @@ void DenseArrayFx::read_dense_array_with_coords_full_global( } // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); CHECK(status == TILEDB_COMPLETED); + // Finalize query + rc = tiledb_query_finalize(ctx_, query); + CHECK(rc == TILEDB_OK); + // Check buffers CHECK(sizeof(c_buffer_a1) == buffer_a1_size); CHECK(sizeof(c_buffer_a2_off) == buffer_a2_off_size); @@ -2247,8 +2173,7 @@ void DenseArrayFx::read_dense_array_with_coords_full_row( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Compute max buffer sizes @@ -2309,19 +2234,17 @@ void DenseArrayFx::read_dense_array_with_coords_full_row( } // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); CHECK(status == TILEDB_COMPLETED); + // Finalize query + rc = tiledb_query_finalize(ctx_, query); + CHECK(rc == TILEDB_OK); + // Check buffers CHECK(sizeof(c_buffer_a1) == buffer_a1_size); CHECK(sizeof(c_buffer_a2_off) == buffer_a2_off_size); @@ -2394,8 +2317,7 @@ void DenseArrayFx::read_dense_array_with_coords_full_col( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Compute max buffer sizes @@ -2456,19 +2378,17 @@ void DenseArrayFx::read_dense_array_with_coords_full_col( } // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); CHECK(status == TILEDB_COMPLETED); + // Finalize query + rc = tiledb_query_finalize(ctx_, query); + CHECK(rc == TILEDB_OK); + // Check buffers CHECK(sizeof(c_buffer_a1) == buffer_a1_size); CHECK(sizeof(c_buffer_a2_off) == buffer_a2_off_size); @@ -2543,8 +2463,7 @@ void DenseArrayFx::read_dense_array_with_coords_subarray_global( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Compute max buffer sizes @@ -2605,19 +2524,17 @@ void DenseArrayFx::read_dense_array_with_coords_subarray_global( } // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); CHECK(status == TILEDB_COMPLETED); + // Finalize query + rc = tiledb_query_finalize(ctx_, query); + CHECK(rc == TILEDB_OK); + // Check buffers CHECK(sizeof(c_buffer_a1) <= buffer_a1_size); CHECK(sizeof(c_buffer_a2_off) <= buffer_a2_off_size); @@ -2691,8 +2608,7 @@ void DenseArrayFx::read_dense_array_with_coords_subarray_row( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Compute max buffer sizes @@ -2753,19 +2669,17 @@ void DenseArrayFx::read_dense_array_with_coords_subarray_row( } // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); CHECK(status == TILEDB_COMPLETED); + // Finalize query + rc = tiledb_query_finalize(ctx_, query); + CHECK(rc == TILEDB_OK); + // Check buffers CHECK(sizeof(c_buffer_a1) == buffer_a1_size); CHECK(sizeof(c_buffer_a2_off) == buffer_a2_off_size); @@ -2839,8 +2753,7 @@ void DenseArrayFx::read_dense_array_with_coords_subarray_col( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Compute max buffer sizes @@ -2901,19 +2814,17 @@ void DenseArrayFx::read_dense_array_with_coords_subarray_col( } // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); CHECK(status == TILEDB_COMPLETED); + // Finalize query + rc = tiledb_query_finalize(ctx_, query); + CHECK(rc == TILEDB_OK); + // Check buffers CHECK(sizeof(c_buffer_a1) == buffer_a1_size); CHECK(sizeof(c_buffer_a2_off) == buffer_a2_off_size); @@ -2968,8 +2879,7 @@ void DenseArrayFx::read_large_dense_array( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create query @@ -2991,19 +2901,17 @@ void DenseArrayFx::read_large_dense_array( CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); CHECK(status == TILEDB_COMPLETED); + // Finalize query + rc = tiledb_query_finalize(ctx_, query); + CHECK(rc == TILEDB_OK); + // Close array rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -3013,16 +2921,15 @@ void DenseArrayFx::read_large_dense_array( tiledb_query_free(&query); } -void DenseArrayFx::check_non_empty_domain(const std::string& path) { - std::string array_name = path + "dense_non_empty_domain"; +void DenseArrayFx::check_non_empty_domain() { + std::string array_name = prefix_ + "dense_non_empty_domain"; create_dense_array(array_name); // Check empty domain tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); int is_empty; uint64_t domain[4]; @@ -3044,8 +2951,7 @@ void DenseArrayFx::check_non_empty_domain(const std::string& path) { write_partial_dense_array(array_name); // Open array - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Check non-empty domain @@ -3096,202 +3002,105 @@ void DenseArrayFx::check_non_empty_domain(const std::string& path) { TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, sorted reads", - "[capi][dense][sorted_reads][longtest]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][dense][sorted_reads][longtest][rest]") { // TODO: refactor for each supported FS. std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); - check_sorted_reads(temp_dir); + check_sorted_reads(); remove_temp_dir(temp_dir); } TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, invalid number of cells in dense writes", - "[capi][dense][invalid_cell_num_writes]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif + "[capi][dense][invalid_cell_num_writes][rest]") { // TODO: refactor for each supported FS. std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); - check_invalid_cell_num_in_dense_writes(temp_dir); + check_invalid_cell_num_in_dense_writes(); remove_temp_dir(temp_dir); } TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, sorted writes", - "[capi][dense][sorted_writes]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][dense][sorted_writes][rest]") { // TODO: refactor for each supported FS. std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); - check_sorted_writes(temp_dir); + check_sorted_writes(); remove_temp_dir(temp_dir); } TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, simultaneous writes", - "[capi][dense][dense-simultaneous-writes]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[capi][dense][dense-simultaneous-writes][rest]") { // TODO: refactor for each supported FS. std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); - check_simultaneous_writes(temp_dir); + check_simultaneous_writes(); remove_temp_dir(temp_dir); } TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, cancel and retry writes", - "[capi][dense][async][cancel]") { - SECTION("- No serialization nor outside subarray") { - serialize_ = false; + "[capi][dense][async][cancel][non-rest]") { + SECTION("- No outside subarray") { use_external_subarray_ = false; } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization, no outside subarray") { - serialize_ = true; - use_external_subarray_ = false; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SECTION("- no serialization, with outside subarray") { - serialize_ = false; + SECTION("- Outside subarray") { use_external_subarray_ = true; } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization, with outside subarray") { - serialize_ = true; - use_external_subarray_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif // TODO: refactor for each supported FS. std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); - check_cancel_and_retry_writes(temp_dir); + check_cancel_and_retry_writes(); remove_temp_dir(temp_dir); } TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, return coordinates", - "[capi][dense][return-coords]") { + "[capi][dense][return-coords][rest]") { bool split_coords = false; - SECTION("- No serialization") { - serialize_ = false; - - SECTION("-- zipped coordinates") { - split_coords = false; - } - - SECTION("-- split coordinates") { - split_coords = true; - } + SECTION("-- zipped coordinates") { + split_coords = false; } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - SECTION("-- zipped coordinates") { - split_coords = false; - } - - SECTION("-- split coordinates") { - split_coords = true; - } + SECTION("-- split coordinates") { + split_coords = true; } -#endif // TODO: refactor for each supported FS. std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); - check_return_coords(temp_dir, split_coords); + check_return_coords(split_coords); remove_temp_dir(temp_dir); } TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, non-empty domain", - "[capi][dense][dense-non-empty]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); + "[capi][dense][dense-non-empty][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); - check_non_empty_domain(temp_dir); + check_non_empty_domain(); remove_temp_dir(temp_dir); } TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, invalid set query buffer", - "[capi][dense][invalid_set_query_buffer]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); + "[capi][dense][invalid_set_query_buffer][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_invalid_set_query_buffer"; // Create and write dense array - std::string array_name = temp_dir + "dense_invalid_set_query_buffer"; create_dense_array(array_name); write_dense_array(array_name); @@ -3299,8 +3108,7 @@ TEST_CASE_METHOD( tiledb_array_t* array; int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Allocate query @@ -3332,27 +3140,14 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_ERR); // Check no buffers set - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_ERR); // Issue an incomplete query rc = tiledb_query_set_data_buffer(ctx_, query, "a1", a1, &a1_size); CHECK(rc == TILEDB_OK); // This is an incomplete query, do not finalize - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check that setting a new attribute for an incomplete query fails @@ -3366,10 +3161,8 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); // Close array - if (serialize_ == false) { - rc = tiledb_array_close(ctx_, array); - CHECK(rc == TILEDB_OK); - } + rc = tiledb_array_close(ctx_, array); + CHECK(rc == TILEDB_OK); // Clean up tiledb_query_free(&query); @@ -3381,13 +3174,12 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, open array checks", - "[capi][dense][open-array-checks]") { - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); + "[capi][dense][open-array-checks][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_open_array"; // Create and write dense array - std::string array_name = temp_dir + "dense_open_array"; create_dense_array(array_name); // Allocate array @@ -3442,13 +3234,7 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_ERR); // Close array @@ -3456,13 +3242,7 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); // Submitting the query after closing an array should fail - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_ERR); // Clean up @@ -3475,13 +3255,11 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, reopen array checks", - "[capi][dense][dense-reopen-array-checks]") { - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); + "[capi][dense][dense-reopen-array-checks][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_open_array"; - // Create and write dense array - std::string array_name = temp_dir + "dense_reopen_array"; create_dense_array(array_name); write_dense_array(array_name); @@ -3522,13 +3300,7 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); rc = tiledb_query_set_subarray(ctx_, query_1, &subarray[0]); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query_1, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query_1); CHECK(rc == TILEDB_OK); // The read query should not see the second fragment @@ -3550,13 +3322,7 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); rc = tiledb_query_set_subarray(ctx_, query_2, &subarray[0]); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query_2, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query_2); CHECK(rc == TILEDB_OK); // The new query see the updated array @@ -3594,21 +3360,12 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, URI ending in a slash", - "[capi][dense][uri-ending-slash]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "with_ending_slash/"; + "[capi][dense][uri-ending-slash][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "with_ending_slash"; + + // Create and write dense array create_dense_array(array_name); write_dense_array(array_name); read_dense_array_with_coords_full_global(array_name, true); @@ -3618,21 +3375,11 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, missing attributes in writes", - "[capi][dense][write-missing-attributes]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_write_missing_attributes/"; + "[capi][dense][write-missing-attributes][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_write_missing_attributes"; + create_dense_array(array_name); write_dense_array_missing_attributes(array_name); remove_temp_dir(temp_dir); @@ -3641,21 +3388,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, read subarrays with empty cells", - "[capi][dense][read_empty]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_read_empty/"; + "[capi][dense][read_empty][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_read_empty"; create_dense_array_1_attribute(array_name); @@ -3679,13 +3415,7 @@ TEST_CASE_METHOD( uint64_t subarray[] = {2, 3, 1, 2}; rc = tiledb_query_set_subarray(ctx_, query, subarray); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -3726,13 +3456,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, attributes[0], read_a1, &read_a1_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -3748,21 +3472,10 @@ TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, read subarrays with empty areas, merging " "adjacent cell ranges", - "[capi][dense][dense-read-empty][dense-read-empty-merge]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_read_empty_merge/"; + "[capi][dense][dense-read-empty][dense-read-empty-merge][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_read_empty_merge"; create_dense_array_1_attribute(array_name); @@ -3786,13 +3499,7 @@ TEST_CASE_METHOD( uint64_t subarray[] = {2, 3, 2, 3}; rc = tiledb_query_set_subarray(ctx_, query, subarray); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -3833,13 +3540,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, attributes[0], read_a1, &read_a1_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -3854,21 +3555,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, multi-fragment reads", - "[capi][dense][dense-multi-fragment]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_multi_fragment/"; + "[capi][dense][dense-multi-fragment][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_multi_fragment/"; create_dense_array_1_attribute(array_name); @@ -3891,13 +3581,7 @@ TEST_CASE_METHOD( uint64_t subarray_1[] = {1, 2, 1, 4}; rc = tiledb_query_set_subarray(ctx_, query, subarray_1); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -3921,13 +3605,7 @@ TEST_CASE_METHOD( uint64_t subarray_2[] = {2, 3, 2, 3}; rc = tiledb_query_set_subarray(ctx_, query, subarray_2); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -3967,13 +3645,7 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query, "a1", read_a, &read_a_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -3988,21 +3660,11 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, check if open", - "[capi][dense][dense-is-open]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_is_open/"; + "[capi][dense][dense-is-open][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_is_open/"; + create_dense_array(array_name); tiledb_array_t* array; @@ -4036,21 +3698,11 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, get schema from opened array", - "[capi][dense][dense-get-schema]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_get_schema/"; + "[capi][dense][dense-get-schema][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_get_schema/"; + create_dense_array(array_name); // Open array @@ -4079,22 +3731,11 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, read in col-major after updates", - "[capi][dense][dense-col-updates]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "dense-col-updates"; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); + "[capi][dense][dense-col-updates][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense-col-updates"; + create_dense_array_1_attribute(array_name); // ------ WRITE QUERIES ------ // @@ -4117,13 +3758,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &wq1, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, wq1); REQUIRE(rc == TILEDB_OK); // Clean up @@ -4150,13 +3785,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, wq2, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &wq2, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, wq2); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_finalize(ctx_, wq2); REQUIRE(rc == TILEDB_OK); @@ -4185,13 +3814,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, wq3, TILEDB_COL_MAJOR); REQUIRE(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &wq3, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, wq3); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_finalize(ctx_, wq3); REQUIRE(rc == TILEDB_OK); @@ -4221,13 +3844,8 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_subarray(ctx_, query, subarray_read); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); + REQUIRE(rc == TILEDB_OK); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); @@ -4255,28 +3873,17 @@ TEST_CASE_METHOD( // TODO: refactor for each supported FS. std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); - check_sorted_reads(temp_dir); + check_sorted_reads(); remove_temp_dir(temp_dir); } TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, splitting to unary ranges", - "[capi][dense][splitting][unary-range]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "unary-range"; + "[capi][dense][splitting][unary-range][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "unary-range"; // Create and write dense array create_dense_array(array_name); @@ -4304,8 +3911,7 @@ TEST_CASE_METHOD( rc = tiledb_array_set_config(ctx_, array, config); CHECK(rc == TILEDB_OK); - rc = array_open_wrapper( - ctx_, TILEDB_READ, (serialize_ && refactored_query_v2_), &array); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); tiledb_query_t* query; @@ -4333,14 +3939,7 @@ TEST_CASE_METHOD( tiledb_query_status_t status; int c_a1[] = {0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15}; for (uint64_t i = 0; i < 16; i++) { - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_query_get_status(ctx_, query, &status); @@ -4362,21 +3961,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, subarray default dim", - "[capi][dense][default-dim]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "default-dim"; + "[capi][dense][default-dim][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "default-dim"; // Create and write dense array create_dense_array(array_name); @@ -4403,13 +3991,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer(ctx_, query, "a1", a1, &a1_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; @@ -4432,21 +4014,11 @@ TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, overlapping fragments, same tile, cell order " "change", - "[capi][dense][overlapping-fragments][same-tile][cell-order-change]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_read_same_tile"; + "[capi][dense][overlapping-fragments][same-tile][cell-order-change][" + "rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_read_same_tile"; create_dense_array_same_tile(array_name); @@ -4480,13 +4052,7 @@ TEST_CASE_METHOD( uint64_t subarray[] = {1, 3, 3, 4}; rc = tiledb_query_set_subarray(ctx_, query, subarray); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_free(&query); @@ -4513,13 +4079,7 @@ TEST_CASE_METHOD( uint64_t subarray_2[] = {4, 5, 1, 4}; rc = tiledb_query_set_subarray(ctx_, query, subarray_2); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -4555,13 +4115,7 @@ TEST_CASE_METHOD( rc = tiledb_query_set_data_buffer( ctx_, query, attributes[1], read_a2, &read_a2_size); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); @@ -4577,18 +4131,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, simple multi-index", - "[capi][dense][multi-index][simple]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_read_multi_index_simple"; + "[capi][dense][multi-index][simple][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_read_multi_index_simple"; create_large_dense_array_1_attribute(array_name); @@ -4634,18 +4180,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, complex multi-index", - "[capi][dense][multi-index][complex]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_read_multi_index_complex"; + "[capi][dense][multi-index][complex][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_read_multi_index_complex"; create_large_dense_array_1_attribute(array_name); @@ -4708,18 +4246,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, multi-index, cross tile boundary", - "[capi][dense][multi-index][cross-tile-boundary]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_read_multi_index_cross_tile"; + "[capi][dense][multi-index][cross-tile-boundary][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_read_multi_index_cross_tile"; create_large_dense_array_1_attribute(array_name); @@ -4765,18 +4295,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, multi-index, out of order ranges", - "[capi][dense][multi-index][out-of-order-ranges]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_read_multi_out_of_order"; + "[capi][dense][multi-index][out-of-order-ranges][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_read_multi_out_of_order"; create_large_dense_array_1_attribute(array_name); @@ -4822,18 +4344,10 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayFx, "C API: Test dense array, multi-index, out of order ranges, coalesce", - "[capi][dense][multi-index][out-of-order-ranges-2]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - std::string array_name = temp_dir + "dense_read_multi_index_coalesce"; + "[capi][dense][multi-index][out-of-order-ranges-2][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); create_temp_dir(temp_dir); + std::string array_name = prefix_ + "dense_read_multi_index_coalesce"; create_large_dense_array_1_attribute(array_name); diff --git a/test/src/unit-capi-dense_neg.cc b/test/src/unit-capi-dense_neg.cc index 734ab104a2b..100d8e821cd 100644 --- a/test/src/unit-capi-dense_neg.cc +++ b/test/src/unit-capi-dense_neg.cc @@ -55,12 +55,6 @@ struct DenseNegFx { // Vector of supported filsystems const std::vector> fs_vec_; - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; - // Functions DenseNegFx(); ~DenseNegFx(); @@ -235,8 +229,7 @@ void DenseNegFx::write_dense_vector(const std::string& path) { rc = tiledb_query_set_layout(ctx_, query, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -270,8 +263,7 @@ void DenseNegFx::write_dense_array_global(const std::string& path) { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -304,8 +296,7 @@ void DenseNegFx::write_dense_array_row(const std::string& path) { rc = tiledb_query_set_layout(ctx_, query, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -338,8 +329,7 @@ void DenseNegFx::write_dense_array_col(const std::string& path) { rc = tiledb_query_set_layout(ctx_, query, TILEDB_COL_MAJOR); REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -372,8 +362,7 @@ void DenseNegFx::read_dense_vector(const std::string& path) { rc = tiledb_query_set_layout(ctx_, query, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); int a_c[] = {0, 1, 2, 3}; @@ -410,8 +399,7 @@ void DenseNegFx::read_dense_array_global(const std::string& path) { rc = tiledb_query_set_subarray(ctx_, query, subarray); REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); int a_c[] = {1, 20, 3, 40, 50, 6, 70, 8, 9, 100, 11, 120, 130, 140, 150, 160}; @@ -448,8 +436,8 @@ void DenseNegFx::read_dense_array_row(const std::string& path) { rc = tiledb_query_set_subarray(ctx_, query, subarray); REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); + REQUIRE(rc == TILEDB_OK); REQUIRE(rc == TILEDB_OK); int a_c[] = {1, 20, 50, 6, 3, 40, 70, 8, 9, 100, 130, 140, 11, 120, 150, 160}; @@ -486,8 +474,8 @@ void DenseNegFx::read_dense_array_col(const std::string& path) { rc = tiledb_query_set_subarray(ctx_, query, subarray); REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); + REQUIRE(rc == TILEDB_OK); REQUIRE(rc == TILEDB_OK); int a_c[] = {1, 3, 9, 11, 20, 40, 100, 120, 50, 70, 130, 150, 6, 8, 140, 160}; @@ -506,55 +494,35 @@ void DenseNegFx::read_dense_array_col(const std::string& path) { TEST_CASE_METHOD( DenseNegFx, "C API: Test 1d dense vector with negative domain", - "[capi][dense-neg][dense-neg-vector]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; + "[capi][dense-neg][dense-neg-vector][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); + create_temp_dir(temp_dir); std::string vector_name = - local_fs.file_prefix() + local_fs.temp_dir() + "dense_neg_vector"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + vfs_array_uri(fs_vec_[0], temp_dir + "dense_neg_vector"); create_dense_vector(vector_name); write_dense_vector(vector_name); read_dense_vector(vector_name); - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + remove_temp_dir(temp_dir); } TEST_CASE_METHOD( DenseNegFx, "C API: Test 2d dense array with negative domain", - "[capi][dense-neg][dense-neg-array]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string vector_name = - local_fs.file_prefix() + local_fs.temp_dir() + "dense_neg_array"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); - - create_dense_array(vector_name); - write_dense_array_global(vector_name); - write_dense_array_row(vector_name); - write_dense_array_col(vector_name); - read_dense_array_global(vector_name); - read_dense_array_row(vector_name); - read_dense_array_col(vector_name); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][dense-neg][dense-neg-array][rest]") { + std::string temp_dir = fs_vec_[0]->temp_dir(); + create_temp_dir(temp_dir); + std::string array_name = + vfs_array_uri(fs_vec_[0], temp_dir + "dense_neg_array"); + + create_dense_array(array_name); + write_dense_array_global(array_name); + write_dense_array_row(array_name); + write_dense_array_col(array_name); + read_dense_array_global(array_name); + read_dense_array_row(array_name); + read_dense_array_col(array_name); + + remove_temp_dir(temp_dir); } diff --git a/test/src/unit-capi-group.cc b/test/src/unit-capi-group.cc index 4c1dee4ecda..87a4468e778 100644 --- a/test/src/unit-capi-group.cc +++ b/test/src/unit-capi-group.cc @@ -415,12 +415,10 @@ TEST_CASE_METHOD( "[capi][group][metadata][rest][regression][sc-4821]") { // Create and open group in write mode // TODO: refactor for each supported FS. - std::string fs_temp_dir = fs_vec_[0]->temp_dir(); - create_temp_dir(fs_temp_dir); - std::string temp_dir = - fs_vec_[0]->is_rest() ? "tiledb://unit/" + fs_temp_dir : fs_temp_dir; + std::string temp_dir = fs_vec_[0]->temp_dir(); + create_temp_dir(temp_dir); + std::string group1_uri = vfs_array_uri(fs_vec_[0], temp_dir + "group1"); - std::string group1_uri = temp_dir + "group1"; REQUIRE(tiledb_group_create(ctx_, group1_uri.c_str()) == TILEDB_OK); tiledb_group_t* group; @@ -512,7 +510,7 @@ TEST_CASE_METHOD( rc = tiledb_group_close(ctx_, group); REQUIRE(rc == TILEDB_OK); tiledb_group_free(&group); - remove_temp_dir(fs_temp_dir); + remove_temp_dir(temp_dir); } TEST_CASE_METHOD( diff --git a/test/src/unit-capi-incomplete-2.cc b/test/src/unit-capi-incomplete-2.cc index fbe58ef12f4..641ab8f2553 100644 --- a/test/src/unit-capi-incomplete-2.cc +++ b/test/src/unit-capi-incomplete-2.cc @@ -32,6 +32,7 @@ #include #include "test/support/src/helpers.h" +#include "test/support/src/vfs_helpers.h" #include "tiledb/sm/c_api/tiledb.h" #include @@ -49,18 +50,16 @@ struct IncompleteFx2 { const char* DENSE_ARRAY_NAME = "test_async_dense"; const char* SPARSE_ARRAY_NAME = "test_async_sparse"; + // VFS setup + VFSTestSetup vfs_test_setup_; + // TileDB context tiledb_ctx_t* ctx_; - - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; + std::string sparse_array_uri_; + std::string dense_array_uri_; // Constructors/destructors IncompleteFx2(); - ~IncompleteFx2(); // Functions void create_dense_array(); @@ -77,19 +76,13 @@ struct IncompleteFx2 { void check_sparse_until_complete(); void check_sparse_unsplittable_overflow(); void check_sparse_unsplittable_complete(); - void remove_dense_array(); - void remove_sparse_array(); - void remove_array(const std::string& array_name); bool is_array(const std::string& array_name); }; -IncompleteFx2::IncompleteFx2() { - ctx_ = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx_) == TILEDB_OK); -} - -IncompleteFx2::~IncompleteFx2() { - tiledb_ctx_free(&ctx_); +IncompleteFx2::IncompleteFx2() + : ctx_(vfs_test_setup_.ctx_c) + , sparse_array_uri_(vfs_test_setup_.array_uri(SPARSE_ARRAY_NAME)) + , dense_array_uri_(vfs_test_setup_.array_uri(DENSE_ARRAY_NAME)) { } void IncompleteFx2::create_dense_array() { @@ -161,7 +154,7 @@ void IncompleteFx2::create_dense_array() { CHECK(rc == TILEDB_OK); // Create array - rc = tiledb_array_create(ctx_, DENSE_ARRAY_NAME, array_schema); + rc = tiledb_array_create(ctx_, dense_array_uri_.c_str(), array_schema); CHECK(rc == TILEDB_OK); // Clean up @@ -243,7 +236,7 @@ void IncompleteFx2::create_sparse_array() { CHECK(rc == TILEDB_OK); // Create array - rc = tiledb_array_create(ctx_, SPARSE_ARRAY_NAME, array_schema); + rc = tiledb_array_create(ctx_, sparse_array_uri_.c_str(), array_schema); CHECK(rc == TILEDB_OK); // Clean up @@ -293,7 +286,7 @@ void IncompleteFx2::write_dense_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); @@ -318,13 +311,7 @@ void IncompleteFx2::write_dense_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -377,7 +364,7 @@ void IncompleteFx2::write_sparse_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); @@ -409,13 +396,7 @@ void IncompleteFx2::write_sparse_full() { CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -427,21 +408,6 @@ void IncompleteFx2::write_sparse_full() { tiledb_query_free(&query); } -void IncompleteFx2::remove_array(const std::string& array_name) { - if (!is_array(array_name)) - return; - - CHECK(tiledb_object_remove(ctx_, array_name.c_str()) == TILEDB_OK); -} - -void IncompleteFx2::remove_dense_array() { - remove_array(DENSE_ARRAY_NAME); -} - -void IncompleteFx2::remove_sparse_array() { - remove_array(SPARSE_ARRAY_NAME); -} - bool IncompleteFx2::is_array(const std::string& array_name) { tiledb_object_t type = TILEDB_INVALID; REQUIRE(tiledb_object_type(ctx_, array_name.c_str(), &type) == TILEDB_OK); @@ -462,7 +428,7 @@ void IncompleteFx2::check_dense_incomplete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -479,14 +445,7 @@ void IncompleteFx2::check_dense_incomplete() { rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); REQUIRE(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check status @@ -496,7 +455,7 @@ void IncompleteFx2::check_dense_incomplete() { CHECK(status == TILEDB_INCOMPLETE); // Finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -527,7 +486,7 @@ void IncompleteFx2::check_dense_until_complete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -545,14 +504,7 @@ void IncompleteFx2::check_dense_until_complete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check buffer @@ -567,14 +519,7 @@ void IncompleteFx2::check_dense_until_complete() { CHECK(status == TILEDB_INCOMPLETE); // Resubmit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check status @@ -588,7 +533,7 @@ void IncompleteFx2::check_dense_until_complete() { CHECK(buffer_sizes[0] == 2 * sizeof(int)); // Finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -614,7 +559,7 @@ void IncompleteFx2::check_dense_shrink_buffer_size() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -632,14 +577,7 @@ void IncompleteFx2::check_dense_shrink_buffer_size() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check buffer @@ -660,14 +598,7 @@ void IncompleteFx2::check_dense_shrink_buffer_size() { CHECK(rc == TILEDB_OK); // Resubmit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check status @@ -680,7 +611,7 @@ void IncompleteFx2::check_dense_shrink_buffer_size() { CHECK(buffer_a1[0] == 2); // Free/finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -707,7 +638,7 @@ void IncompleteFx2::check_dense_unsplittable_overflow() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -728,14 +659,7 @@ void IncompleteFx2::check_dense_unsplittable_overflow() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Get status @@ -748,7 +672,7 @@ void IncompleteFx2::check_dense_unsplittable_overflow() { CHECK(buffer_sizes[1] == 0); // Finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -775,7 +699,7 @@ void IncompleteFx2::check_dense_unsplittable_complete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -796,14 +720,8 @@ void IncompleteFx2::check_dense_unsplittable_complete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); + REQUIRE(rc == TILEDB_OK); REQUIRE(rc == TILEDB_OK); // Check buffers @@ -811,7 +729,7 @@ void IncompleteFx2::check_dense_unsplittable_complete() { CHECK(!memcmp(buffer_a2_var, c_buffer_a2_var, sizeof(c_buffer_a2_var))); // Finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -837,7 +755,7 @@ void IncompleteFx2::check_dense_reset_buffers() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -855,14 +773,8 @@ void IncompleteFx2::check_dense_reset_buffers() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); + REQUIRE(rc == TILEDB_OK); REQUIRE(rc == TILEDB_OK); // Check buffer @@ -877,14 +789,8 @@ void IncompleteFx2::check_dense_reset_buffers() { CHECK(status == TILEDB_INCOMPLETE); // Resubmit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); + REQUIRE(rc == TILEDB_OK); REQUIRE(rc == TILEDB_OK); // Check status @@ -898,7 +804,7 @@ void IncompleteFx2::check_dense_reset_buffers() { CHECK(buffer_sizes[0] == 2 * sizeof(int)); // Finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -921,7 +827,7 @@ void IncompleteFx2::check_sparse_incomplete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -945,14 +851,7 @@ void IncompleteFx2::check_sparse_incomplete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check status @@ -986,7 +885,7 @@ void IncompleteFx2::check_sparse_until_complete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -1010,14 +909,7 @@ void IncompleteFx2::check_sparse_until_complete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check status @@ -1032,14 +924,7 @@ void IncompleteFx2::check_sparse_until_complete() { CHECK(buffer_sizes[0] == sizeof(int)); // Resubmit the query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check status @@ -1053,14 +938,7 @@ void IncompleteFx2::check_sparse_until_complete() { CHECK(buffer_sizes[0] == sizeof(int)); // Resubmit the query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check status @@ -1092,7 +970,7 @@ void IncompleteFx2::check_sparse_unsplittable_overflow() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -1119,14 +997,8 @@ void IncompleteFx2::check_sparse_unsplittable_overflow() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); + REQUIRE(rc == TILEDB_OK); REQUIRE(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); @@ -1135,7 +1007,7 @@ void IncompleteFx2::check_sparse_unsplittable_overflow() { CHECK(buffer_sizes[0] == 0); // Finalize query - rc = finalize_query_wrapper(ctx_, SPARSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -1159,7 +1031,7 @@ void IncompleteFx2::check_sparse_unsplittable_complete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -1186,14 +1058,7 @@ void IncompleteFx2::check_sparse_unsplittable_complete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check buffers @@ -1201,7 +1066,7 @@ void IncompleteFx2::check_sparse_unsplittable_complete() { CHECK(!memcmp(buffer_a2_var, c_buffer_a2_var, sizeof(c_buffer_a2_var))); // Finalize query - rc = finalize_query_wrapper(ctx_, SPARSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -1216,18 +1081,7 @@ void IncompleteFx2::check_sparse_unsplittable_complete() { TEST_CASE_METHOD( IncompleteFx2, "C API: Test incomplete read queries 2, dense", - "[capi][incomplete-2][dense-incomplete-2]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - remove_dense_array(); + "[capi][incomplete-2][dense-incomplete-2][rest]") { create_dense_array(); write_dense_full(); check_dense_incomplete(); @@ -1236,29 +1090,16 @@ TEST_CASE_METHOD( check_dense_unsplittable_overflow(); check_dense_unsplittable_complete(); check_dense_reset_buffers(); - remove_dense_array(); } TEST_CASE_METHOD( IncompleteFx2, "C API: Test incomplete read queries 2, sparse", - "[capi][incomplete-2][sparse-incomplete-2]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - remove_sparse_array(); + "[capi][incomplete-2][sparse-incomplete-2][rest-fails][sc-42873]") { create_sparse_array(); write_sparse_full(); check_sparse_incomplete(); check_sparse_until_complete(); check_sparse_unsplittable_overflow(); check_sparse_unsplittable_complete(); - remove_sparse_array(); } diff --git a/test/src/unit-capi-incomplete.cc b/test/src/unit-capi-incomplete.cc index ae780736003..2d4d6dc8d15 100644 --- a/test/src/unit-capi-incomplete.cc +++ b/test/src/unit-capi-incomplete.cc @@ -32,6 +32,7 @@ #include #include "test/support/src/helpers.h" +#include "test/support/src/vfs_helpers.h" #include "tiledb/sm/c_api/tiledb.h" #include "tiledb/sm/c_api/tiledb_serialization.h" #include "tiledb/sm/serialization/query.h" @@ -51,18 +52,16 @@ struct IncompleteFx { const char* DENSE_ARRAY_NAME = "test_async_dense"; const char* SPARSE_ARRAY_NAME = "test_async_sparse"; + // VFS setup + VFSTestSetup vfs_test_setup_; + // TileDB context tiledb_ctx_t* ctx_; - - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; + std::string sparse_array_uri_; + std::string dense_array_uri_; // Constructors/destructors IncompleteFx(); - ~IncompleteFx(); // Functions void create_dense_array(); @@ -79,19 +78,13 @@ struct IncompleteFx { void check_sparse_until_complete(); void check_sparse_unsplittable_overflow(); void check_sparse_unsplittable_complete(); - void remove_dense_array(); - void remove_sparse_array(); - void remove_array(const std::string& array_name); bool is_array(const std::string& array_name); }; -IncompleteFx::IncompleteFx() { - ctx_ = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx_) == TILEDB_OK); -} - -IncompleteFx::~IncompleteFx() { - tiledb_ctx_free(&ctx_); +IncompleteFx::IncompleteFx() + : ctx_(vfs_test_setup_.ctx_c) + , sparse_array_uri_(vfs_test_setup_.array_uri(SPARSE_ARRAY_NAME)) + , dense_array_uri_(vfs_test_setup_.array_uri(DENSE_ARRAY_NAME)) { } void IncompleteFx::create_dense_array() { @@ -163,7 +156,7 @@ void IncompleteFx::create_dense_array() { CHECK(rc == TILEDB_OK); // Create array - rc = tiledb_array_create(ctx_, DENSE_ARRAY_NAME, array_schema); + rc = tiledb_array_create(ctx_, dense_array_uri_.c_str(), array_schema); CHECK(rc == TILEDB_OK); // Clean up @@ -245,7 +238,7 @@ void IncompleteFx::create_sparse_array() { CHECK(rc == TILEDB_OK); // Create array - rc = tiledb_array_create(ctx_, SPARSE_ARRAY_NAME, array_schema); + rc = tiledb_array_create(ctx_, sparse_array_uri_.c_str(), array_schema); CHECK(rc == TILEDB_OK); // Clean up @@ -295,7 +288,7 @@ void IncompleteFx::write_dense_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); @@ -319,13 +312,7 @@ void IncompleteFx::write_dense_full() { ctx_, query, attributes[2], buffers[3], &buffer_sizes[3]); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -378,7 +365,7 @@ void IncompleteFx::write_sparse_full() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); @@ -409,14 +396,8 @@ void IncompleteFx::write_sparse_full() { ctx_, query, attributes[4], buffers[5], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); - CHECK(rc == TILEDB_OK); + rc = tiledb_query_submit_and_finalize(ctx_, query); + REQUIRE(rc == TILEDB_OK); // Close array rc = tiledb_array_close(ctx_, array); @@ -427,21 +408,6 @@ void IncompleteFx::write_sparse_full() { tiledb_query_free(&query); } -void IncompleteFx::remove_array(const std::string& array_name) { - if (!is_array(array_name)) - return; - - CHECK(tiledb_object_remove(ctx_, array_name.c_str()) == TILEDB_OK); -} - -void IncompleteFx::remove_dense_array() { - remove_array(DENSE_ARRAY_NAME); -} - -void IncompleteFx::remove_sparse_array() { - remove_array(SPARSE_ARRAY_NAME); -} - bool IncompleteFx::is_array(const std::string& array_name) { tiledb_object_t type = TILEDB_INVALID; REQUIRE(tiledb_object_type(ctx_, array_name.c_str(), &type) == TILEDB_OK); @@ -462,7 +428,7 @@ void IncompleteFx::check_dense_incomplete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -480,14 +446,7 @@ void IncompleteFx::check_dense_incomplete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check status @@ -497,7 +456,7 @@ void IncompleteFx::check_dense_incomplete() { CHECK(status == TILEDB_INCOMPLETE); // Free/finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -528,7 +487,7 @@ void IncompleteFx::check_dense_until_complete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -546,14 +505,7 @@ void IncompleteFx::check_dense_until_complete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffer @@ -568,14 +520,7 @@ void IncompleteFx::check_dense_until_complete() { CHECK(status == TILEDB_INCOMPLETE); // Resubmit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check status @@ -589,7 +534,7 @@ void IncompleteFx::check_dense_until_complete() { CHECK(buffer_sizes[0] == 2 * sizeof(int)); // Free/finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -615,7 +560,7 @@ void IncompleteFx::check_dense_shrink_buffer_size() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -633,14 +578,7 @@ void IncompleteFx::check_dense_shrink_buffer_size() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffer @@ -661,14 +599,7 @@ void IncompleteFx::check_dense_shrink_buffer_size() { CHECK(rc == TILEDB_OK); // Resubmit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check status @@ -681,7 +612,7 @@ void IncompleteFx::check_dense_shrink_buffer_size() { CHECK(buffer_a1[0] == 2); // Free/finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -708,7 +639,7 @@ void IncompleteFx::check_dense_unsplittable_overflow() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -729,14 +660,7 @@ void IncompleteFx::check_dense_unsplittable_overflow() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Get status @@ -749,7 +673,7 @@ void IncompleteFx::check_dense_unsplittable_overflow() { CHECK(buffer_sizes[1] == 0); // Finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -776,7 +700,7 @@ void IncompleteFx::check_dense_unsplittable_complete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -797,14 +721,7 @@ void IncompleteFx::check_dense_unsplittable_complete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffers @@ -812,7 +729,7 @@ void IncompleteFx::check_dense_unsplittable_complete() { CHECK(!memcmp(buffer_a2_var, c_buffer_a2_var, sizeof(c_buffer_a2_var))); // Finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -838,7 +755,7 @@ void IncompleteFx::check_dense_reset_buffers() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, DENSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, dense_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -856,14 +773,7 @@ void IncompleteFx::check_dense_reset_buffers() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffer @@ -878,14 +788,7 @@ void IncompleteFx::check_dense_reset_buffers() { CHECK(status == TILEDB_INCOMPLETE); // Resubmit query - rc = submit_query_wrapper( - ctx_, - DENSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check status @@ -899,7 +802,7 @@ void IncompleteFx::check_dense_reset_buffers() { CHECK(buffer_sizes[0] == 2 * sizeof(int)); // Finalize query - rc = finalize_query_wrapper(ctx_, DENSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -925,7 +828,7 @@ void IncompleteFx::check_sparse_incomplete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -943,14 +846,7 @@ void IncompleteFx::check_sparse_incomplete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check status @@ -960,7 +856,7 @@ void IncompleteFx::check_sparse_incomplete() { CHECK(status == TILEDB_INCOMPLETE); // Finalize query - rc = finalize_query_wrapper(ctx_, SPARSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -991,7 +887,7 @@ void IncompleteFx::check_sparse_until_complete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -1009,14 +905,7 @@ void IncompleteFx::check_sparse_until_complete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check status @@ -1031,14 +920,7 @@ void IncompleteFx::check_sparse_until_complete() { CHECK(buffer_sizes[0] == sizeof(int)); // Resubmit the query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check status @@ -1060,14 +942,7 @@ void IncompleteFx::check_sparse_until_complete() { */ if (!use_refactored_sparse_global_order_reader()) { // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check status @@ -1103,7 +978,7 @@ void IncompleteFx::check_sparse_unsplittable_overflow() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -1125,14 +1000,7 @@ void IncompleteFx::check_sparse_unsplittable_overflow() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); @@ -1140,19 +1008,13 @@ void IncompleteFx::check_sparse_unsplittable_overflow() { CHECK(status == TILEDB_INCOMPLETE); CHECK(buffer_sizes[0] == 0); - // For remote arrays the reason is always TILEDB_REASON_USER_BUFFER_SIZE, but - // we can't test it here since we simulate "remote" arrays by using a local - // URI so the array->is_remote() check will fail, and we won't get the - // correct result. - if (!serialize_) { - tiledb_query_status_details_t details; - rc = tiledb_query_get_status_details(ctx_, query, &details); - CHECK(rc == TILEDB_OK); - CHECK(details.incomplete_reason == TILEDB_REASON_USER_BUFFER_SIZE); - } + tiledb_query_status_details_t details; + rc = tiledb_query_get_status_details(ctx_, query, &details); + CHECK(rc == TILEDB_OK); + CHECK(details.incomplete_reason == TILEDB_REASON_USER_BUFFER_SIZE); // Finalize query - rc = finalize_query_wrapper(ctx_, SPARSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -1179,7 +1041,7 @@ void IncompleteFx::check_sparse_unsplittable_complete() { // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx_, SPARSE_ARRAY_NAME, &array); + int rc = tiledb_array_alloc(ctx_, sparse_array_uri_.c_str(), &array); CHECK(rc == TILEDB_OK); rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); @@ -1200,14 +1062,7 @@ void IncompleteFx::check_sparse_unsplittable_complete() { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Check buffers @@ -1215,7 +1070,7 @@ void IncompleteFx::check_sparse_unsplittable_complete() { CHECK(!memcmp(buffer_a2_var, c_buffer_a2_var, sizeof(c_buffer_a2_var))); // Finalize query - rc = finalize_query_wrapper(ctx_, SPARSE_ARRAY_NAME, &query, serialize_); + rc = tiledb_query_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -1230,18 +1085,7 @@ void IncompleteFx::check_sparse_unsplittable_complete() { TEST_CASE_METHOD( IncompleteFx, "C API: Test incomplete read queries, dense", - "[capi][incomplete][dense-incomplete][serialization]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - remove_dense_array(); + "[capi][incomplete][dense-incomplete][serialization][rest]") { create_dense_array(); write_dense_full(); check_dense_incomplete(); @@ -1250,54 +1094,25 @@ TEST_CASE_METHOD( check_dense_unsplittable_overflow(); check_dense_unsplittable_complete(); check_dense_reset_buffers(); - remove_dense_array(); } TEST_CASE_METHOD( IncompleteFx, "C API: Test incomplete read queries, sparse", - "[capi][incomplete][sparse][serialization]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - remove_sparse_array(); + "[capi][incomplete][sparse][serialization][rest]") { create_sparse_array(); write_sparse_full(); check_sparse_incomplete(); check_sparse_until_complete(); check_sparse_unsplittable_overflow(); check_sparse_unsplittable_complete(); - remove_sparse_array(); } -#ifdef TILEDB_SERIALIZATION - TEST_CASE_METHOD( IncompleteFx, "C API: Test incomplete read queries, dense, serialized", - "[capi][incomplete][dense][serialization]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - remove_dense_array(); + "[capi][incomplete][dense][serialization][rest]") { create_dense_array(); write_dense_full(); check_dense_incomplete(); - remove_dense_array(); } - -#endif diff --git a/test/src/unit-capi-nullable.cc b/test/src/unit-capi-nullable.cc index bd93abc576a..0be84fe640e 100644 --- a/test/src/unit-capi-nullable.cc +++ b/test/src/unit-capi-nullable.cc @@ -33,6 +33,7 @@ #include #include "test/support/src/helpers.h" #include "test/support/src/temporary_local_directory.h" +#include "test/support/src/vfs_helpers.h" #include "tiledb/api/c_api/vfs/vfs_api_internal.h" #include "tiledb/sm/c_api/tiledb.h" #include "tiledb/sm/enums/array_type.h" @@ -48,12 +49,6 @@ using namespace tiledb::test; class NullableArrayFx { public: - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; - struct test_dim_t { test_dim_t( const string& name, @@ -200,8 +195,7 @@ class NullableArrayFx { const void* subarray); }; -NullableArrayFx::NullableArrayFx() - : serialize_(false) { +NullableArrayFx::NullableArrayFx() { // Create a config. tiledb_config_t* config = nullptr; tiledb_error_t* error = nullptr; @@ -224,7 +218,7 @@ NullableArrayFx::~NullableArrayFx() { } const string NullableArrayFx::array_path(const string& array_name) { - return temp_dir_.path() + array_name; + return vfs_array_uri(vfs_test_get_fs_vec()[0], temp_dir_.path() + array_name); } void NullableArrayFx::create_array( @@ -410,13 +404,11 @@ void NullableArrayFx::write( } // Submit query - rc = submit_query_wrapper( - ctx_, - array_path(array_name), - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + if (layout != TILEDB_GLOBAL_ORDER) { + rc = tiledb_query_submit(ctx_, query); + } else { + rc = tiledb_query_submit_and_finalize(ctx_, query); + } REQUIRE(rc == TILEDB_OK); // Clean up @@ -517,13 +509,7 @@ void NullableArrayFx::read( REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_path(array_name), - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Clean up @@ -848,20 +834,12 @@ void NullableArrayFx::do_2d_nullable_test( } } +// TODO: Add [rest] tag and fix test issues with cleanup +// because of the use of dynamic section TEST_CASE_METHOD( NullableArrayFx, "C API: Test 2D array with nullable attributes", "[capi][2d][nullable]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - // Define the attributes. vector attrs; attrs.emplace_back("a1", TILEDB_INT32, 1, true); diff --git a/test/src/unit-capi-rest-dense_array.cc b/test/src/unit-capi-rest-dense_array.cc index 553cec87688..f985aeaa495 100644 --- a/test/src/unit-capi-rest-dense_array.cc +++ b/test/src/unit-capi-rest-dense_array.cc @@ -1179,7 +1179,11 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( DenseArrayRESTFx, "C API: REST Test dense array, simultaneous writes", - "[capi][rest][dense][dense-simultaneous-writes]") { + "[capi][non-rest][dense][dense-simultaneous-writes]") { + // Parallel array open requests on the same array fail on + // remote arrays, as locking cannot work on Cloud REST + // server to synchronize them, so we exclude this test + // from REST-CI check_simultaneous_writes(); } diff --git a/test/src/unit-capi-serialized_queries.cc b/test/src/unit-capi-serialized_queries.cc index be67e818703..a91a5ef68a8 100644 --- a/test/src/unit-capi-serialized_queries.cc +++ b/test/src/unit-capi-serialized_queries.cc @@ -32,6 +32,7 @@ #include #include "test/support/src/helpers.h" +#include "test/support/src/vfs_helpers.h" #include "tiledb/common/common.h" #include "tiledb/sm/c_api/tiledb.h" #include "tiledb/sm/c_api/tiledb_serialization.h" @@ -54,23 +55,8 @@ using namespace tiledb; using ResultSetType = std::map; -using tiledb::test::ServerQueryBuffers; -using tiledb::test::submit_query_wrapper; - namespace { -#ifdef _WIN32 -static const char PATH_SEPARATOR = '\\'; -static std::string current_dir() { - return sm::Win::current_dir(); -} -#else -static const char PATH_SEPARATOR = '/'; -static std::string current_dir() { - return sm::Posix::current_dir(); -} -#endif - template bool check_result(const T a, const T b, size_t start, size_t end) { auto a_exp = T(a.begin() + start, a.begin() + end); @@ -99,34 +85,15 @@ bool check_result( } struct SerializationFx { - const std::string tmpdir = "serialization_test_dir"; - const std::string array_name = "testarray"; - const std::string array_uri = - current_dir() + PATH_SEPARATOR + tmpdir + "/" + array_name; - + test::VFSTestSetup vfs_test_setup_; + tiledb_ctx_t* ctx_; Context ctx; - VFS vfs; - - // Serialization parameters - bool serialize_ = true; - bool refactored_query_v2_ = false; - bool finalize_ = false; - // Buffers to allocate on server side for serialized queries - tiledb::test::ServerQueryBuffers server_buffers_; + const std::string array_uri; SerializationFx() - : vfs(ctx) { - if (vfs.is_dir(tmpdir)) - vfs.remove_dir(tmpdir); - vfs.create_dir(tmpdir); - if (!vfs.is_dir(tmpdir)) - std::cerr << "'created' but not finding dir '" << tmpdir << "'" - << std::endl; - } - - ~SerializationFx() { - if (vfs.is_dir(tmpdir)) - vfs.remove_dir(tmpdir); + : ctx_{vfs_test_setup_.ctx_c} + , ctx{vfs_test_setup_.ctx()} + , array_uri{vfs_test_setup_.array_uri("testarray")} { } static void check_read_stats(const Query& query) { @@ -218,15 +185,7 @@ struct SerializationFx { query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the write stats check_write_stats(query); @@ -268,23 +227,15 @@ struct SerializationFx { query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the write stats check_write_stats(query); } void write_sparse_array() { - std::vector coords = {1, 1, 2, 2, 3, 3, 4, 4, 5, 5, - 6, 6, 7, 7, 8, 8, 9, 9, 10, 10}; + std::vector d1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + std::vector d2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; std::vector a1; std::vector a2; std::vector a2_nullable; @@ -308,7 +259,8 @@ struct SerializationFx { Array array(ctx, array_uri, TILEDB_WRITE); Query query(ctx, array); query.set_layout(TILEDB_UNORDERED); - query.set_coordinates(coords); + query.set_data_buffer("d1", d1); + query.set_data_buffer("d2", d2); query.set_data_buffer("a1", a1); query.set_data_buffer("a2", a2); query.set_validity_buffer("a2", a2_nullable); @@ -316,15 +268,7 @@ struct SerializationFx { query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the write stats check_write_stats(query); @@ -341,15 +285,7 @@ struct SerializationFx { query.set_condition(qc); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the delete stats check_delete_stats(query); @@ -392,15 +328,7 @@ struct SerializationFx { query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the write stats check_write_stats(query); @@ -412,8 +340,7 @@ struct SerializationFx { TEST_CASE_METHOD( SerializationFx, "Query serialization, dense", - "[query][dense][serialization]") { - refactored_query_v2_ = GENERATE(true, false); + "[query][dense][serialization][rest]") { create_array(TILEDB_DENSE); auto expected_results = write_dense_array(); @@ -435,15 +362,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -485,15 +404,7 @@ TEST_CASE_METHOD( query.set_condition(condition); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -551,15 +462,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -607,15 +510,7 @@ TEST_CASE_METHOD( // Submit initial query. set_buffers(query); - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); REQUIRE(query.query_status() == Query::Status::INCOMPLETE); @@ -629,15 +524,7 @@ TEST_CASE_METHOD( // Reset buffers, serialize and resubmit set_buffers(query); - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -653,15 +540,7 @@ TEST_CASE_METHOD( // Reset buffers, serialize and resubmit set_buffers(query); - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -680,15 +559,13 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SerializationFx, "Query serialization, sparse", - "[query][sparse][serialization]") { - refactored_query_v2_ = GENERATE(true, false); + "[query][sparse][serialization][rest]") { create_array(TILEDB_SPARSE); write_sparse_array(); SECTION("- Read all") { Array array(ctx, array_uri, TILEDB_READ); Query query(ctx, array); - std::vector coords(1000); std::vector a1(1000); std::vector a2(1000); std::vector a2_nullable(1000); @@ -697,7 +574,6 @@ TEST_CASE_METHOD( std::vector subarray = {1, 10, 1, 10}; query.set_subarray(subarray); - query.set_coordinates(coords); query.set_data_buffer("a1", a1); query.set_data_buffer("a2", a2); query.set_validity_buffer("a2", a2_nullable); @@ -705,15 +581,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -732,20 +600,21 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SerializationFx, "Query serialization, sparse, old client", - "[query][sparse][serialization][old-client]") { - refactored_query_v2_ = GENERATE(true, false); + "[query][sparse][serialization][old-client][rest]") { create_array(TILEDB_SPARSE); write_sparse_array(); Config config; config.set("sm.query.sparse_global_order.reader", "legacy"); config.set("sm.query.sparse_unordered_with_dups.reader", "legacy"); - auto ctx_client = Context(config); + + vfs_test_setup_.update_config(config.ptr().get()); + ctx_ = vfs_test_setup_.ctx_c; + auto ctx_client = vfs_test_setup_.ctx(); SECTION("- Read all") { Array array(ctx_client, array_uri, TILEDB_READ); Query query(ctx_client, array); - std::vector coords(1000); std::vector a1(1000); std::vector a2(1000); std::vector a2_nullable(1000); @@ -755,7 +624,6 @@ TEST_CASE_METHOD( query.set_layout(TILEDB_GLOBAL_ORDER); query.set_subarray(subarray); - query.set_coordinates(coords); query.set_data_buffer("a1", a1); query.set_data_buffer("a2", a2); query.set_validity_buffer("a2", a2_nullable); @@ -763,15 +631,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -791,7 +651,6 @@ TEST_CASE_METHOD( SerializationFx, "Query serialization, split coords, sparse", "[query][sparse][serialization][split-coords]") { - refactored_query_v2_ = GENERATE(true, false); create_array(TILEDB_SPARSE); write_sparse_array_split_coords(); @@ -815,15 +674,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -843,8 +694,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SerializationFx, "Query serialization, dense ranges", - "[query][dense][serialization]") { - refactored_query_v2_ = GENERATE(true, false); + "[query][dense][serialization][rest]") { create_array(TILEDB_DENSE); write_dense_array_ranges(); @@ -867,15 +717,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -909,15 +751,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -955,15 +789,7 @@ TEST_CASE_METHOD( // Submit initial query. set_buffers(query); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); REQUIRE(query.query_status() == Query::Status::INCOMPLETE); @@ -978,15 +804,7 @@ TEST_CASE_METHOD( // Reset buffers, serialize and resubmit set_buffers(query); // Submit query - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -1001,15 +819,7 @@ TEST_CASE_METHOD( // Reset buffers, serialize and resubmit set_buffers(query); // Submit query - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -1028,8 +838,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SerializationFx, "Query serialization, sparse delete", - "[query][sparse][delete][serialization]") { - refactored_query_v2_ = GENERATE(true, false); + "[query][sparse][delete][serialization][rest]") { create_array(TILEDB_SPARSE); write_sparse_array(); write_sparse_delete(); @@ -1037,7 +846,6 @@ TEST_CASE_METHOD( SECTION("- Read all") { Array array(ctx, array_uri, TILEDB_READ); Query query(ctx, array); - std::vector coords(1000); std::vector a1(1000); std::vector a2(1000); std::vector a2_nullable(1000); @@ -1046,7 +854,6 @@ TEST_CASE_METHOD( std::vector subarray = {1, 10, 1, 10}; query.set_subarray(subarray); - query.set_coordinates(coords); query.set_data_buffer("a1", a1); query.set_data_buffer("a2", a2); query.set_validity_buffer("a2", a2_nullable); @@ -1054,15 +861,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the read stats check_read_stats(query); @@ -1081,17 +880,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SerializationFx, "Global order writes serialization", - "[global-order-write][serialization][dense]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[global-order-write][serialization][dense][rest]") { uint64_t tile_extent = 2; ArraySchema schema(ctx, TILEDB_DENSE); Domain domain(ctx); @@ -1150,29 +939,13 @@ TEST_CASE_METHOD( begin += chunk_size; end = std::min(last_space_tile, end + chunk_size); - // Simulate REST submit() if (begin < end) { - submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + query.submit(); } } // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); - REQUIRE(rc == TILEDB_OK); - + query.submit_and_finalize(); REQUIRE(query.query_status() == Query::Status::COMPLETE); // Read and validate results @@ -1195,14 +968,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer( "a3", a3_result_offsets.data(), a3_result_offsets.size()); - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::COMPLETE); for (uint64_t i = 0; i < ncells; ++i) { @@ -1224,13 +990,7 @@ TEST_CASE_METHOD( SerializationFx, "Derialization of a var size read query correctly resets original buffer " "sizes", - "[capi][query][serialization][reset-buffers]") { -#ifndef TILEDB_SERIALIZATION - // Only makes sense in serialization - return; -#endif - refactored_query_v2_ = GENERATE(true, false); - + "[capi][query][serialization][reset-buffers][rest]") { create_array(TILEDB_SPARSE); write_sparse_array(); @@ -1251,16 +1011,7 @@ TEST_CASE_METHOD( set_buffers(); Query::Status status; do { - int rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - true, - refactored_query_v2_, - false); - REQUIRE(rc == TILEDB_OK); - + query.submit(); status = query.query_status(); } while (status == Query::Status::INCOMPLETE); diff --git a/test/src/unit-capi-serialized_queries_using_subarray.cc b/test/src/unit-capi-serialized_queries_using_subarray.cc index a8d6499212b..cda10080732 100644 --- a/test/src/unit-capi-serialized_queries_using_subarray.cc +++ b/test/src/unit-capi-serialized_queries_using_subarray.cc @@ -35,6 +35,7 @@ #include #include "test/support/src/helpers.h" +#include "test/support/src/vfs_helpers.h" #include "tiledb/sm/c_api/tiledb_serialization.h" #include "tiledb/sm/c_api/tiledb_struct_def.h" #include "tiledb/sm/cpp_api/tiledb" @@ -55,23 +56,8 @@ using namespace tiledb; using ResultSetType = std::map; -using tiledb::test::ServerQueryBuffers; -using tiledb::test::submit_query_wrapper; - namespace { -#ifdef _WIN32 -static const char PATH_SEPARATOR = '\\'; -static std::string current_dir() { - return sm::Win::current_dir(); -} -#else -static const char PATH_SEPARATOR = '/'; -static std::string current_dir() { - return sm::Posix::current_dir(); -} -#endif - template bool check_result(const T a, const T b, size_t start, size_t end) { auto a_exp = T(a.begin() + start, a.begin() + end); @@ -100,34 +86,15 @@ bool check_result( } struct SerializationFx { - const std::string tmpdir = "serialization_test_dir"; - const std::string array_name = "testarray"; - const std::string array_uri = - current_dir() + PATH_SEPARATOR + tmpdir + "/" + array_name; - + test::VFSTestSetup vfs_test_setup_; + tiledb_ctx_t* ctx_; Context ctx; - VFS vfs; - - // Serialization parameters - bool serialize_ = true; - bool refactored_query_v2_ = false; - bool finalize_ = false; - // Buffers to allocate on server side for serialized queries - tiledb::test::ServerQueryBuffers server_buffers_; + const std::string array_uri; SerializationFx() - : vfs(ctx) { - if (vfs.is_dir(tmpdir)) - vfs.remove_dir(tmpdir); - vfs.create_dir(tmpdir); - if (!vfs.is_dir(tmpdir)) - std::cerr << "'created' but not finding dir '" << tmpdir << "'" - << std::endl; - } - - ~SerializationFx() { - if (vfs.is_dir(tmpdir)) - vfs.remove_dir(tmpdir); + : ctx_{vfs_test_setup_.ctx_c} + , ctx{vfs_test_setup_.ctx()} + , array_uri{vfs_test_setup_.array_uri("testarray")} { } static void check_read_stats(const Query& query) { @@ -226,15 +193,7 @@ struct SerializationFx { query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); // The deserialized query should also include the write stats check_write_stats(query); @@ -278,20 +237,12 @@ struct SerializationFx { query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); } void write_sparse_array() { - std::vector coords = {1, 1, 2, 2, 3, 3, 4, 4, 5, 5, - 6, 6, 7, 7, 8, 8, 9, 9, 10, 10}; + std::vector d1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + std::vector d2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; std::vector a1; std::vector a2; std::vector a2_nullable; @@ -315,7 +266,8 @@ struct SerializationFx { Array array(ctx, array_uri, TILEDB_WRITE); Query query(ctx, array); query.set_layout(TILEDB_UNORDERED); - query.set_coordinates(coords); + query.set_data_buffer("d1", d1); + query.set_data_buffer("d2", d2); query.set_data_buffer("a1", a1); query.set_data_buffer("a2", a2); query.set_validity_buffer("a2", a2_nullable); @@ -323,15 +275,7 @@ struct SerializationFx { query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); } void write_sparse_array_split_coords() { @@ -371,15 +315,7 @@ struct SerializationFx { query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); } }; @@ -388,8 +324,12 @@ struct SerializationFx { TEST_CASE_METHOD( SerializationFx, "subarray - Query serialization, dense", - "[query][dense][serialization]") { - refactored_query_v2_ = GENERATE(true, false); + "[query][dense][serialization][rest][sc-40489]") { + if (!vfs_test_setup_.is_rest()) { + SUCCEED("sc-40489: this test passes on remote arrays only"); + return; + } + create_array(TILEDB_DENSE); auto expected_results = write_dense_array(); check_subarray_stats(2, 2); @@ -417,15 +357,7 @@ TEST_CASE_METHOD( check_subarray_stats(3, 3); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::COMPLETE); // Check stats after serialization @@ -465,15 +397,7 @@ TEST_CASE_METHOD( query.set_condition(condition); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::COMPLETE); // The deserialized query should also include the write stats @@ -535,15 +459,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::COMPLETE); check_subarray_stats(5, 5); @@ -578,15 +494,7 @@ TEST_CASE_METHOD( // Submit initial query. set_buffers(query); - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); check_subarray_stats(5, 5); REQUIRE(query.query_status() == Query::Status::INCOMPLETE); @@ -599,15 +507,7 @@ TEST_CASE_METHOD( // Reset buffers, serialize and resubmit set_buffers(query); - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); check_subarray_stats(7, 7); REQUIRE(query.query_status() == Query::Status::INCOMPLETE); @@ -620,15 +520,7 @@ TEST_CASE_METHOD( // Reset buffers, serialize and resubmit set_buffers(query); - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); check_subarray_stats(9, 9); REQUIRE(query.query_status() == Query::Status::COMPLETE); @@ -644,15 +536,13 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SerializationFx, "subarray - Query serialization, sparse", - "[query][sparse][serialization]") { - refactored_query_v2_ = GENERATE(true, false); + "[query][sparse][serialization][rest]") { create_array(TILEDB_SPARSE); write_sparse_array(); SECTION("- Read all") { Array array(ctx, array_uri, TILEDB_READ); Query query(ctx, array); - std::vector coords(1000); std::vector a1(1000); std::vector a2(1000); std::vector a2_nullable(1000); @@ -664,7 +554,6 @@ TEST_CASE_METHOD( cppapi_subarray.set_subarray(subarray); query.set_subarray(cppapi_subarray); - query.set_coordinates(coords); query.set_data_buffer("a1", a1); query.set_data_buffer("a2", a2); query.set_validity_buffer("a2", a2_nullable); @@ -672,15 +561,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::COMPLETE); auto result_el = query.result_buffer_elements_nullable(); @@ -696,7 +577,6 @@ TEST_CASE_METHOD( SerializationFx, "subarray - Query serialization, split coords, sparse", "[query][sparse][serialization][split-coords]") { - refactored_query_v2_ = GENERATE(true, false); create_array(TILEDB_SPARSE); write_sparse_array_split_coords(); @@ -722,15 +602,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::COMPLETE); auto result_el = query.result_buffer_elements_nullable(); @@ -746,8 +618,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SerializationFx, "subarray - Query serialization, dense ranges", - "[query][dense][serialization]") { - refactored_query_v2_ = GENERATE(true, false); + "[query][dense][serialization][rest]") { create_array(TILEDB_DENSE); write_dense_array_ranges(); @@ -772,15 +643,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::COMPLETE); auto result_el = query.result_buffer_elements_nullable(); @@ -812,15 +675,7 @@ TEST_CASE_METHOD( query.set_offsets_buffer("a3", a3_offsets); // Submit query - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::COMPLETE); auto result_el = query.result_buffer_elements_nullable(); @@ -855,15 +710,7 @@ TEST_CASE_METHOD( // Submit initial query. set_buffers(query); - auto rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::INCOMPLETE); auto result_el = query.result_buffer_elements_nullable(); @@ -876,15 +723,7 @@ TEST_CASE_METHOD( // Reset buffers, serialize and resubmit set_buffers(query); // Submit query - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::INCOMPLETE); result_el = query.result_buffer_elements_nullable(); @@ -897,15 +736,7 @@ TEST_CASE_METHOD( // Reset buffers, serialize and resubmit set_buffers(query); // Submit query - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - finalize_); - REQUIRE(rc == TILEDB_OK); + query.submit(); REQUIRE(query.query_status() == Query::Status::COMPLETE); result_el = query.result_buffer_elements_nullable(); diff --git a/test/src/unit-capi-sparse_array.cc b/test/src/unit-capi-sparse_array.cc index 2766031cb88..4bfc283727d 100644 --- a/test/src/unit-capi-sparse_array.cc +++ b/test/src/unit-capi-sparse_array.cc @@ -86,12 +86,8 @@ struct SparseArrayFx { // Vector of supported filsystems const std::vector> fs_vec_; - - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; + // Path to prepend to array name according to filesystem/mode + std::string prefix_; // Functions SparseArrayFx(); @@ -118,7 +114,7 @@ struct SparseArrayFx { void check_sparse_array_global_with_all_duplicates_dedup( const std::string& array_name); void check_sparse_array_no_results(const std::string& array_name); - void check_non_empty_domain(const std::string& path); + void check_non_empty_domain(const std::string& array_name); void check_invalid_offsets(const std::string& array_name); void write_partial_sparse_array(const std::string& array_name); void write_sparse_array_missing_attributes(const std::string& array_name); @@ -138,7 +134,6 @@ struct SparseArrayFx { tiledb_filter_type_t compressor, tiledb_layout_t tile_order, tiledb_layout_t cell_order); - void remove_array(const std::string& array_name); bool is_array(const std::string& array_name); /** @@ -223,6 +218,8 @@ SparseArrayFx::SparseArrayFx() for (const auto& fs : fs_vec_) create_temp_dir(fs->temp_dir()); + + prefix_ = vfs_array_uri(fs_vec_[0], fs_vec_[0]->temp_dir()); } SparseArrayFx::~SparseArrayFx() { @@ -235,19 +232,6 @@ SparseArrayFx::~SparseArrayFx() { tiledb_ctx_free(&ctx_); } -bool SparseArrayFx::is_array(const std::string& array_name) { - tiledb_object_t type = TILEDB_INVALID; - REQUIRE(tiledb_object_type(ctx_, array_name.c_str(), &type) == TILEDB_OK); - return type == TILEDB_ARRAY; -} - -void SparseArrayFx::remove_array(const std::string& array_name) { - if (!is_array(array_name)) - return; - - CHECK(tiledb_object_remove(ctx_, array_name.c_str()) == TILEDB_OK); -} - void SparseArrayFx::create_temp_dir(const std::string& path) { remove_temp_dir(path); REQUIRE(tiledb_vfs_create_dir(ctx_, vfs_, path.c_str()) == TILEDB_OK); @@ -982,9 +966,11 @@ void SparseArrayFx::check_sparse_array_unordered_with_duplicates_no_check( tiledb_config_set(config, "sm.check_coord_dups", "false", &error) == TILEDB_OK); REQUIRE(error == nullptr); - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); - REQUIRE(error == nullptr); + + tiledb_ctx_free(&ctx_); + tiledb_vfs_free(&vfs_); + // reallocate with input config + vfs_test_init(fs_vec_, &ctx_, &vfs_, config).ok(); tiledb_config_free(&config); // Prepare cell buffers @@ -1026,51 +1012,50 @@ void SparseArrayFx::check_sparse_array_unordered_with_duplicates_no_check( // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create query tiledb_query_t* query; const char* attributes[] = {"a1", "a2", "a3", "d1", "d2"}; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], buffers[0], &buffer_sizes[0]); + ctx_, query, attributes[0], buffers[0], &buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[1], buffers[2], &buffer_sizes[2]); + ctx_, query, attributes[1], buffers[2], &buffer_sizes[2]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); + ctx_, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], buffers[3], &buffer_sizes[3]); + ctx_, query, attributes[2], buffers[3], &buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], buffers[4], &buffer_sizes[4]); + ctx_, query, attributes[3], buffers[4], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], buffers[5], &buffer_sizes[4]); + ctx_, query, attributes[4], buffers[5], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); // Submit query - this is unsafe but it should be passing - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - tiledb_ctx_free(&ctx); } void SparseArrayFx::check_sparse_array_unordered_with_duplicates_dedup( @@ -1084,9 +1069,11 @@ void SparseArrayFx::check_sparse_array_unordered_with_duplicates_dedup( tiledb_config_set(config, "sm.dedup_coords", "true", &error) == TILEDB_OK); REQUIRE(error == nullptr); - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); - REQUIRE(error == nullptr); + + tiledb_ctx_free(&ctx_); + tiledb_vfs_free(&vfs_); + // reallocate with input config + vfs_test_init(fs_vec_, &ctx_, &vfs_, config).ok(); tiledb_config_free(&config); // Prepare cell buffers for WRITE @@ -1128,45 +1115,45 @@ void SparseArrayFx::check_sparse_array_unordered_with_duplicates_dedup( // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; const char* attributes[] = {"a1", "a2", "a3", "d1", "d2"}; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], buffers[0], &buffer_sizes[0]); + ctx_, query, attributes[0], buffers[0], &buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[1], buffers[2], &buffer_sizes[2]); + ctx_, query, attributes[1], buffers[2], &buffer_sizes[2]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); + ctx_, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], buffers[3], &buffer_sizes[3]); + ctx_, query, attributes[2], buffers[3], &buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], buffers[4], &buffer_sizes[4]); + ctx_, query, attributes[3], buffers[4], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], buffers[5], &buffer_sizes[4]); + ctx_, query, attributes[4], buffers[5], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); // Submit WRITE query - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up @@ -1194,37 +1181,37 @@ void SparseArrayFx::check_sparse_array_unordered_with_duplicates_dedup( sizeof(r_buffer_coords_dim1)}; // Open array - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create READ query - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], r_buffers[0], &r_buffer_sizes[0]); + ctx_, query, attributes[0], r_buffers[0], &r_buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[1], r_buffers[2], &r_buffer_sizes[2]); + ctx_, query, attributes[1], r_buffers[2], &r_buffer_sizes[2]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, query, attributes[1], (uint64_t*)r_buffers[1], &r_buffer_sizes[1]); + ctx_, query, attributes[1], (uint64_t*)r_buffers[1], &r_buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], r_buffers[3], &r_buffer_sizes[3]); + ctx_, query, attributes[2], r_buffers[3], &r_buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], r_buffers[4], &r_buffer_sizes[4]); + ctx_, query, attributes[3], r_buffers[4], &r_buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], r_buffers[5], &r_buffer_sizes[4]); + ctx_, query, attributes[4], r_buffers[5], &r_buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); // Submit READ query - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Check correctness @@ -1262,13 +1249,12 @@ void SparseArrayFx::check_sparse_array_unordered_with_duplicates_dedup( sizeof(c_buffer_coords_dim2))); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - tiledb_ctx_free(&ctx); } void SparseArrayFx::check_sparse_array_unordered_with_all_duplicates_dedup( @@ -1282,9 +1268,11 @@ void SparseArrayFx::check_sparse_array_unordered_with_all_duplicates_dedup( tiledb_config_set(config, "sm.dedup_coords", "true", &error) == TILEDB_OK); REQUIRE(error == nullptr); - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); - REQUIRE(error == nullptr); + + tiledb_ctx_free(&ctx_); + tiledb_vfs_free(&vfs_); + // reallocate with input config + vfs_test_init(fs_vec_, &ctx_, &vfs_, config).ok(); tiledb_config_free(&config); // Prepare cell buffers for WRITE @@ -1326,45 +1314,45 @@ void SparseArrayFx::check_sparse_array_unordered_with_all_duplicates_dedup( // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; const char* attributes[] = {"a1", "a2", "a3", "d1", "d2"}; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], buffers[0], &buffer_sizes[0]); + ctx_, query, attributes[0], buffers[0], &buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[1], buffers[2], &buffer_sizes[2]); + ctx_, query, attributes[1], buffers[2], &buffer_sizes[2]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); + ctx_, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], buffers[3], &buffer_sizes[3]); + ctx_, query, attributes[2], buffers[3], &buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], buffers[4], &buffer_sizes[4]); + ctx_, query, attributes[3], buffers[4], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], buffers[5], &buffer_sizes[4]); + ctx_, query, attributes[4], buffers[5], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); // Submit WRITE query - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up @@ -1392,41 +1380,41 @@ void SparseArrayFx::check_sparse_array_unordered_with_all_duplicates_dedup( sizeof(r_buffer_coords_dim1)}; // Open array - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create READ query - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], r_buffers[0], &r_buffer_sizes[0]); + ctx_, query, attributes[0], r_buffers[0], &r_buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[1], r_buffers[2], &r_buffer_sizes[2]); + ctx_, query, attributes[1], r_buffers[2], &r_buffer_sizes[2]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, query, attributes[1], (uint64_t*)r_buffers[1], &r_buffer_sizes[1]); + ctx_, query, attributes[1], (uint64_t*)r_buffers[1], &r_buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], r_buffers[3], &r_buffer_sizes[3]); + ctx_, query, attributes[2], r_buffers[3], &r_buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], r_buffers[4], &r_buffer_sizes[4]); + ctx_, query, attributes[3], r_buffers[4], &r_buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], r_buffers[5], &r_buffer_sizes[4]); + ctx_, query, attributes[4], r_buffers[5], &r_buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); REQUIRE(rc == TILEDB_OK); // Submit READ query - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up @@ -1452,8 +1440,6 @@ void SparseArrayFx::check_sparse_array_unordered_with_all_duplicates_dedup( r_buffer_coords_dim2, c_buffer_coords_dim2, sizeof(c_buffer_coords_dim2))); - - tiledb_ctx_free(&ctx); } void SparseArrayFx::check_sparse_array_global_with_duplicates_error( @@ -1529,10 +1515,8 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_error( CHECK(rc == TILEDB_OK); // Submit query - rc = tiledb_query_submit(ctx_, query); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_ERR); - rc = tiledb_query_finalize(ctx_, query); - CHECK(rc == TILEDB_OK); // Close array rc = tiledb_array_close(ctx_, array); @@ -1554,9 +1538,11 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_no_check( tiledb_config_set(config, "sm.check_coord_dups", "false", &error) == TILEDB_OK); REQUIRE(error == nullptr); - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); - REQUIRE(error == nullptr); + + tiledb_ctx_free(&ctx_); + tiledb_vfs_free(&vfs_); + // reallocate with input config + vfs_test_init(fs_vec_, &ctx_, &vfs_, config).ok(); tiledb_config_free(&config); // Prepare cell buffers @@ -1598,20 +1584,20 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_no_check( // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create query tiledb_query_t* query; const char* attributes[] = {"a1", "a2", "a3", "d1", "d2"}; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], buffers[0], &buffer_sizes[0]); + ctx_, query, attributes[0], buffers[0], &buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( ctx_, query, attributes[1], buffers[2], &buffer_sizes[2]); @@ -1620,21 +1606,21 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_no_check( ctx_, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], buffers[3], &buffer_sizes[3]); + ctx_, query, attributes[2], buffers[3], &buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], buffers[4], &buffer_sizes[4]); + ctx_, query, attributes[3], buffers[4], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], buffers[5], &buffer_sizes[4]); + ctx_, query, attributes[4], buffers[5], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); // Submit query - this is unsafe but it should be passing - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Finalize query - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -1644,7 +1630,6 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_no_check( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - tiledb_ctx_free(&ctx); } void SparseArrayFx::check_sparse_array_global_with_duplicates_dedup( @@ -1658,9 +1643,11 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_dedup( tiledb_config_set(config, "sm.dedup_coords", "true", &error) == TILEDB_OK); REQUIRE(error == nullptr); - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); - REQUIRE(error == nullptr); + + tiledb_ctx_free(&ctx_); + tiledb_vfs_free(&vfs_); + // reallocate with input config + vfs_test_init(fs_vec_, &ctx_, &vfs_, config).ok(); tiledb_config_free(&config); // Prepare cell buffers for WRITE @@ -1702,20 +1689,20 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_dedup( // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; const char* attributes[] = {"a1", "a2", "a3", "d1", "d2"}; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], buffers[0], &buffer_sizes[0]); + ctx_, query, attributes[0], buffers[0], &buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( ctx_, query, attributes[1], buffers[2], &buffer_sizes[2]); @@ -1724,23 +1711,23 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_dedup( ctx_, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], buffers[3], &buffer_sizes[3]); + ctx_, query, attributes[2], buffers[3], &buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], buffers[4], &buffer_sizes[4]); + ctx_, query, attributes[3], buffers[4], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], buffers[5], &buffer_sizes[4]); + ctx_, query, attributes[4], buffers[5], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); // Submit WRITE query - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up @@ -1768,14 +1755,14 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_dedup( sizeof(r_buffer_coords_dim1)}; // Open array - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create READ query - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], r_buffers[0], &r_buffer_sizes[0]); + ctx_, query, attributes[0], r_buffers[0], &r_buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( ctx_, query, attributes[1], r_buffers[2], &r_buffer_sizes[2]); @@ -1784,27 +1771,27 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_dedup( ctx_, query, attributes[1], (uint64_t*)r_buffers[1], &r_buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], r_buffers[3], &r_buffer_sizes[3]); + ctx_, query, attributes[2], r_buffers[3], &r_buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], r_buffers[4], &r_buffer_sizes[4]); + ctx_, query, attributes[3], r_buffers[4], &r_buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], r_buffers[5], &r_buffer_sizes[4]); + ctx_, query, attributes[4], r_buffers[5], &r_buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); // Submit READ query - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Finalize query - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up @@ -1845,8 +1832,6 @@ void SparseArrayFx::check_sparse_array_global_with_duplicates_dedup( r_buffer_coords_dim2, c_buffer_coords_dim2, sizeof(c_buffer_coords_dim2))); - - tiledb_ctx_free(&ctx); } void SparseArrayFx::check_sparse_array_global_with_all_duplicates_dedup( @@ -1860,9 +1845,11 @@ void SparseArrayFx::check_sparse_array_global_with_all_duplicates_dedup( tiledb_config_set(config, "sm.dedup_coords", "true", &error) == TILEDB_OK); REQUIRE(error == nullptr); - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); - REQUIRE(error == nullptr); + + tiledb_ctx_free(&ctx_); + tiledb_vfs_free(&vfs_); + // reallocate with input config + vfs_test_init(fs_vec_, &ctx_, &vfs_, config).ok(); tiledb_config_free(&config); // Prepare cell buffers for WRITE @@ -1904,20 +1891,20 @@ void SparseArrayFx::check_sparse_array_global_with_all_duplicates_dedup( // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; const char* attributes[] = {"a1", "a2", "a3", "d1", "d2"}; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], buffers[0], &buffer_sizes[0]); + ctx_, query, attributes[0], buffers[0], &buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( ctx_, query, attributes[1], buffers[2], &buffer_sizes[2]); @@ -1926,23 +1913,23 @@ void SparseArrayFx::check_sparse_array_global_with_all_duplicates_dedup( ctx_, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], buffers[3], &buffer_sizes[3]); + ctx_, query, attributes[2], buffers[3], &buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], buffers[4], &buffer_sizes[4]); + ctx_, query, attributes[3], buffers[4], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], buffers[5], &buffer_sizes[4]); + ctx_, query, attributes[4], buffers[5], &buffer_sizes[4]); CHECK(rc == TILEDB_OK); // Submit WRITE query - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up @@ -1970,14 +1957,14 @@ void SparseArrayFx::check_sparse_array_global_with_all_duplicates_dedup( sizeof(r_buffer_coords_dim1)}; // Open array - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create READ query - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], r_buffers[0], &r_buffer_sizes[0]); + ctx_, query, attributes[0], r_buffers[0], &r_buffer_sizes[0]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( ctx_, query, attributes[1], r_buffers[2], &r_buffer_sizes[2]); @@ -1986,25 +1973,25 @@ void SparseArrayFx::check_sparse_array_global_with_all_duplicates_dedup( ctx_, query, attributes[1], (uint64_t*)r_buffers[1], &r_buffer_sizes[1]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], r_buffers[3], &r_buffer_sizes[3]); + ctx_, query, attributes[2], r_buffers[3], &r_buffer_sizes[3]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[3], r_buffers[4], &r_buffer_sizes[4]); + ctx_, query, attributes[3], r_buffers[4], &r_buffer_sizes[4]); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[4], r_buffers[5], &r_buffer_sizes[4]); + ctx_, query, attributes[4], r_buffers[5], &r_buffer_sizes[4]); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_UNORDERED); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); REQUIRE(rc == TILEDB_OK); // Submit READ query - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx, query); + rc = tiledb_query_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up @@ -2031,12 +2018,9 @@ void SparseArrayFx::check_sparse_array_global_with_all_duplicates_dedup( r_buffer_coords_dim2, c_buffer_coords_dim2, sizeof(c_buffer_coords_dim2))); - - tiledb_ctx_free(&ctx); } -void SparseArrayFx::check_non_empty_domain(const std::string& path) { - std::string array_name = path + "sparse_non_empty"; +void SparseArrayFx::check_non_empty_domain(const std::string& array_name) { create_sparse_array(array_name); // Check empty domain @@ -2193,7 +2177,7 @@ void SparseArrayFx::check_sparse_array_no_results( CHECK(rc == TILEDB_OK); // Prepare the buffers that will store the result - uint64_t buffer_size = 0; + uint64_t buffer_size = 1; auto buffer = new int[buffer_size / sizeof(int)]; REQUIRE(buffer != nullptr); @@ -2385,93 +2369,61 @@ void SparseArrayFx::write_sparse_array_missing_attributes( TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, sorted reads", - "[capi][sparse][sorted-reads][longtest]") { - std::string array_name; + "[capi][sparse][sorted-reads][longtest][rest]") { + // TODO: refactor for each supported FS. + std::string array_name = prefix_ + ARRAY; SECTION("- no compression, row/row-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_NONE, TILEDB_ROW_MAJOR, TILEDB_ROW_MAJOR); } SECTION("- no compression, col/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_NONE, TILEDB_COL_MAJOR, TILEDB_COL_MAJOR); } SECTION("- no compression, row/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_NONE, TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); } SECTION("- gzip compression, row/row-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_GZIP, TILEDB_ROW_MAJOR, TILEDB_ROW_MAJOR); } SECTION("- gzip compression, col/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_GZIP, TILEDB_COL_MAJOR, TILEDB_COL_MAJOR); } SECTION("- gzip compression, row/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_GZIP, TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); } SECTION("- bzip compression, row/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_BZIP2, TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); } SECTION("- lz4 compression, row/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_LZ4, TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); } SECTION("- rle compression, row/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_RLE, TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); } SECTION("- zstd compression, row/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_ZSTD, TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); } SECTION("- double-delta compression, row/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_DOUBLE_DELTA, @@ -2480,21 +2432,18 @@ TEST_CASE_METHOD( } SECTION("- delta compression, row/col-major") { - // TODO: refactor for each supported FS. - std::string temp_dir = fs_vec_[0]->temp_dir(); - array_name = temp_dir + ARRAY; check_sorted_reads( array_name, TILEDB_FILTER_DELTA, TILEDB_ROW_MAJOR, TILEDB_COL_MAJOR); } + + remove_temp_dir(fs_vec_[0]->temp_dir()); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, duplicates", - "[capi][sparse][dups]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "dups"; + "[capi][sparse][dups][rest-fails][sc-42987]") { + std::string array_name = prefix_ + "dups"; create_sparse_array(array_name); SECTION("- unordered, error check") { @@ -2533,21 +2482,16 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, non-empty domain", - "[capi][sparse][non-empty]") { - SupportedFsLocal local_fs; - std::string temp_dir = local_fs.file_prefix() + local_fs.temp_dir(); - create_temp_dir(temp_dir); - check_non_empty_domain(temp_dir); - remove_temp_dir(temp_dir); + "[capi][sparse][non-empty][rest]") { + std::string array_name = prefix_ + "sparse_non_empty"; + check_non_empty_domain(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, invalid offsets on write", - "[capi][sparse][invalid-offsets]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "invalid_offs"; + "[capi][sparse][invalid-offsets][rest]") { + std::string array_name = prefix_ + "invalid_offs"; create_sparse_array(array_name); check_invalid_offsets(array_name); } @@ -2555,10 +2499,8 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, no results", - "[capi][sparse][no-results]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "no_results"; + "[capi][sparse][no-results][rest-fails][sc-43108]") { + std::string array_name = prefix_ + "no_results"; create_sparse_array(array_name); write_partial_sparse_array(array_name); check_sparse_array_no_results(array_name); @@ -2567,10 +2509,8 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, missing attributes in writes", - "[capi][sparse][write-missing-attributes]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_write_missing_attributes"; + "[capi][sparse][write-missing-attributes][rest-fails][sc-43108]") { + std::string array_name = prefix_ + "sparse_write_missing_attributes"; create_sparse_array(array_name); write_sparse_array_missing_attributes(array_name); check_sparse_array_no_results(array_name); @@ -2579,26 +2519,20 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, error setting subarray on sparse write", - "[capi][sparse][set-subarray]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_set_subarray"; + "[capi][sparse][set-subarray][rest]") { + std::string array_name = prefix_ + "sparse_set_subarray"; create_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); // Set subarray @@ -2609,181 +2543,160 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); // Submit - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_ERR); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, check if coords exist", - "[capi][sparse][coords-exist]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_coords_exist"; + "[capi][sparse][coords-exist][rest-fails][sc-43108]") { + std::string array_name = prefix_ + "sparse_coords_exist"; create_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_GLOBAL_ORDER); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); CHECK(rc == TILEDB_OK); // Set attribute buffers int a1[] = {1, 2}; uint64_t a1_size = sizeof(a1); - rc = tiledb_query_set_data_buffer(ctx, query, "a1", a1, &a1_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a1", a1, &a1_size); CHECK(rc == TILEDB_OK); char a2[] = {'a', 'b'}; uint64_t a2_size = sizeof(a2); uint64_t a2_off[] = {0, 1}; uint64_t a2_off_size = sizeof(a2_off); - rc = tiledb_query_set_data_buffer(ctx, query, "a2", a2, &a2_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a2", a2, &a2_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_offsets_buffer(ctx, query, "a2", a2_off, &a2_off_size); + rc = tiledb_query_set_offsets_buffer(ctx_, query, "a2", a2_off, &a2_off_size); CHECK(rc == TILEDB_OK); float a3[] = {1.1f, 1.2f, 2.1f, 2.2f}; uint64_t a3_size = sizeof(a3); - rc = tiledb_query_set_data_buffer(ctx, query, "a3", a3, &a3_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a3", a3, &a3_size); CHECK(rc == TILEDB_OK); // Submit query - should error - CHECK(tiledb_query_submit(ctx, query) == TILEDB_ERR); + CHECK(tiledb_query_submit(ctx_, query) == TILEDB_ERR); // Set coordinates uint64_t coords_dim1[] = {1, 1}; uint64_t coords_dim2[] = {1, 2}; uint64_t coords_size = sizeof(coords_dim1); - rc = - tiledb_query_set_data_buffer(ctx, query, "d1", coords_dim1, &coords_size); + rc = tiledb_query_set_data_buffer( + ctx_, query, "d1", coords_dim1, &coords_size); CHECK(rc == TILEDB_OK); - rc = - tiledb_query_set_data_buffer(ctx, query, "d2", coords_dim2, &coords_size); + rc = tiledb_query_set_data_buffer( + ctx_, query, "d2", coords_dim2, &coords_size); CHECK(rc == TILEDB_OK); // Submit query - ok - CHECK(tiledb_query_submit(ctx, query) == TILEDB_OK); + CHECK(tiledb_query_submit(ctx_, query) == TILEDB_OK); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, global order check on write", - "[capi][sparse][write-global-check]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_write_global_check"; + "[capi][sparse][write-global-check][rest]") { + std::string array_name = prefix_ + "sparse_write_global_check"; create_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_GLOBAL_ORDER); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); CHECK(rc == TILEDB_OK); // Set attribute buffers int a1[] = {1, 2}; uint64_t a1_size = sizeof(a1); - rc = tiledb_query_set_data_buffer(ctx, query, "a1", a1, &a1_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a1", a1, &a1_size); CHECK(rc == TILEDB_OK); char a2[] = {'a', 'b'}; uint64_t a2_size = sizeof(a2); uint64_t a2_off[] = {0, 1}; uint64_t a2_off_size = sizeof(a2_off); - rc = tiledb_query_set_data_buffer(ctx, query, "a2", a2, &a2_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a2", a2, &a2_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_offsets_buffer(ctx, query, "a2", a2_off, &a2_off_size); + rc = tiledb_query_set_offsets_buffer(ctx_, query, "a2", a2_off, &a2_off_size); CHECK(rc == TILEDB_OK); float a3[] = {1.1f, 1.2f, 2.1f, 2.2f}; uint64_t a3_size = sizeof(a3); - rc = tiledb_query_set_data_buffer(ctx, query, "a3", a3, &a3_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a3", a3, &a3_size); CHECK(rc == TILEDB_OK); // Set coordinates uint64_t coords_dim1[] = {1, 1}; uint64_t coords_dim2[] = {2, 1}; uint64_t coords_size = sizeof(coords_dim1); - rc = - tiledb_query_set_data_buffer(ctx, query, "d1", coords_dim1, &coords_size); + rc = tiledb_query_set_data_buffer( + ctx_, query, "d1", coords_dim1, &coords_size); CHECK(rc == TILEDB_OK); - rc = - tiledb_query_set_data_buffer(ctx, query, "d2", coords_dim2, &coords_size); + rc = tiledb_query_set_data_buffer( + ctx_, query, "d2", coords_dim2, &coords_size); CHECK(rc == TILEDB_OK); // Submit query - ok - CHECK(tiledb_query_submit(ctx, query) == TILEDB_ERR); + CHECK(tiledb_query_submit(ctx_, query) == TILEDB_ERR); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, invalidate cached max buffer sizes", - "[capi][sparse][invalidate-max-sizes]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_invalidate_max_sizes"; + "[capi][sparse][invalidate-max-sizes][rest]") { + std::string array_name = prefix_ + "sparse_invalidate_max_sizes"; create_sparse_array(array_name); write_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // ---- First READ query (empty) tiledb_query_t* empty_query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &empty_query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &empty_query); CHECK(rc == TILEDB_OK); // Get max buffer sizes for empty query @@ -2795,25 +2708,25 @@ TEST_CASE_METHOD( // Set attribute buffers auto a1 = (int*)malloc(a1_size); - rc = tiledb_query_set_data_buffer(ctx, empty_query, "a1", a1, &a1_size); + rc = tiledb_query_set_data_buffer(ctx_, empty_query, "a1", a1, &a1_size); CHECK(rc == TILEDB_OK); auto a2_off = (uint64_t*)malloc(a2_off_size); auto a2 = (char*)malloc(a2_size); - rc = tiledb_query_set_data_buffer(ctx, empty_query, "a2", a2, &a2_size); + rc = tiledb_query_set_data_buffer(ctx_, empty_query, "a2", a2, &a2_size); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, empty_query, "a2", a2_off, &a2_off_size); + ctx_, empty_query, "a2", a2_off, &a2_off_size); CHECK(rc == TILEDB_OK); auto a3 = (float*)malloc(a3_size); - rc = tiledb_query_set_data_buffer(ctx, empty_query, "a3", a3, &a3_size); + rc = tiledb_query_set_data_buffer(ctx_, empty_query, "a3", a3, &a3_size); CHECK(rc == TILEDB_OK); auto coords_dim1 = (uint64_t*)malloc(coords_size); auto coords_dim2 = (uint64_t*)malloc(coords_size); rc = tiledb_query_set_data_buffer( - ctx, empty_query, "d1", coords_dim1, &coords_size); + ctx_, empty_query, "d1", coords_dim1, &coords_size); CHECK(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, empty_query, "d2", coords_dim2, &coords_size); + ctx_, empty_query, "d2", coords_dim2, &coords_size); CHECK(rc == TILEDB_OK); // Set subarray @@ -2827,7 +2740,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); // Submit query - CHECK(tiledb_query_submit(ctx, empty_query) == TILEDB_OK); + CHECK(tiledb_query_submit(ctx_, empty_query) == TILEDB_OK); // Check that there are no results CHECK(a1_size == 0); @@ -2846,7 +2759,7 @@ TEST_CASE_METHOD( // ---- Second READ query (non-empty) tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); // Set max buffer sizes for non-empty query @@ -2858,24 +2771,24 @@ TEST_CASE_METHOD( // Set attribute buffers a1 = (int*)malloc(a1_size); - rc = tiledb_query_set_data_buffer(ctx, query, "a1", a1, &a1_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a1", a1, &a1_size); CHECK(rc == TILEDB_OK); a2_off = (uint64_t*)malloc(a2_off_size); a2 = (char*)malloc(a2_size); - rc = tiledb_query_set_data_buffer(ctx, query, "a2", a2, &a2_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a2", a2, &a2_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_offsets_buffer(ctx, query, "a2", a2_off, &a2_off_size); + rc = tiledb_query_set_offsets_buffer(ctx_, query, "a2", a2_off, &a2_off_size); CHECK(rc == TILEDB_OK); a3 = (float*)malloc(a3_size); - rc = tiledb_query_set_data_buffer(ctx, query, "a3", a3, &a3_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a3", a3, &a3_size); CHECK(rc == TILEDB_OK); coords_dim1 = (uint64_t*)malloc(coords_size); coords_dim2 = (uint64_t*)malloc(coords_size); - rc = - tiledb_query_set_data_buffer(ctx, query, "d1", coords_dim1, &coords_size); + rc = tiledb_query_set_data_buffer( + ctx_, query, "d1", coords_dim1, &coords_size); CHECK(rc == TILEDB_OK); - rc = - tiledb_query_set_data_buffer(ctx, query, "d2", coords_dim2, &coords_size); + rc = tiledb_query_set_data_buffer( + ctx_, query, "d2", coords_dim2, &coords_size); CHECK(rc == TILEDB_OK); // Set subarray @@ -2891,7 +2804,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); // Submit query - CHECK(tiledb_query_submit(ctx, query) == TILEDB_OK); + CHECK(tiledb_query_submit(ctx_, query) == TILEDB_OK); // Check that there are no results REQUIRE(a1_size == 2 * sizeof(int)); @@ -2920,15 +2833,14 @@ TEST_CASE_METHOD( tiledb_query_free(&query); // Clean up - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, encrypted", - "[capi][sparse][encryption]") { + "[capi][sparse][encryption][non-rest]") { std::string array_name; encryption_type = TILEDB_AES_256_GCM; encryption_key = "0123456789abcdeF0123456789abcdeF"; @@ -2944,31 +2856,25 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, calibrate est size", - "[capi][sparse][calibrate-est-size]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_calibrate_est_size"; - remove_array(array_name); + "[capi][sparse][calibrate-est-size][rest]") { + std::string array_name = prefix_ + "sparse_calibrate_est_size"; + create_sparse_array(array_name); // Write twice (2 fragments) write_sparse_array(array_name); write_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); int a1[2]; uint64_t a1_size = sizeof(a1); @@ -2993,7 +2899,7 @@ TEST_CASE_METHOD( rc = tiledb_query_add_range(ctx_, query, 1, &s1[0], &s1[1], nullptr); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); @@ -3012,44 +2918,35 @@ TEST_CASE_METHOD( CHECK(a2[2] == 'b'); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, calibrate est size, unary", - "[capi][sparse][calibrate-est-size-unary]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_calibrate_est_size_unary"; - remove_array(array_name); + "[capi][sparse][calibrate-est-size-unary][rest]") { + std::string array_name = prefix_ + "sparse_calibrate_est_size_unary"; + create_sparse_array(array_name); // Write twice (2 fragments) write_sparse_array(array_name); write_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); int a1[1]; uint64_t a1_size = sizeof(a1); @@ -3074,7 +2971,7 @@ TEST_CASE_METHOD( rc = tiledb_query_add_range(ctx_, query, 1, &s1[0], &s1[1], nullptr); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); @@ -3089,45 +2986,36 @@ TEST_CASE_METHOD( CHECK(a2_size == sizeof(char)); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, calibrate est size, huge range", - "[capi][sparse][calibrate-est-size-huge-range]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_calibrate_est_size_huge_range"; + "[capi][sparse][calibrate-est-size-huge-range][rest]") { + std::string array_name = prefix_ + "sparse_calibrate_est_size_huge_range"; const uint64_t dim_domain[4] = {1, UINT64_MAX - 1, 1, UINT64_MAX - 1}; - remove_array(array_name); + create_sparse_array(array_name, TILEDB_ROW_MAJOR, dim_domain); // Write twice (2 fragments) write_sparse_array(array_name); write_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); int a1[2] = {-1, -1}; uint64_t a1_size = sizeof(a1); @@ -3152,7 +3040,7 @@ TEST_CASE_METHOD( rc = tiledb_query_add_range(ctx_, query, 1, &s1[0], &s1[1], nullptr); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); @@ -3171,41 +3059,32 @@ TEST_CASE_METHOD( CHECK(a2_size == 3 * sizeof(char)); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-subarray, 2D, complete", - "[capi][sparse][MR][2D][complete]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_subarray_2d_complete"; - remove_array(array_name); + "[capi][sparse][MR][2D][complete][rest]") { + std::string array_name = prefix_ + "sparse_multi_subarray_2d_complete"; + create_sparse_array(array_name); write_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); int a1[20]; uint64_t a1_size = sizeof(a1); @@ -3237,7 +3116,7 @@ TEST_CASE_METHOD( rc = tiledb_query_add_range(ctx_, query, 1, &s11[0], &s11[1], nullptr); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); @@ -3263,24 +3142,19 @@ TEST_CASE_METHOD( CHECK(coords_dim2[4] == 4); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-subarray, 2D, multiplicities", - "[capi][sparse][multi-subarray-2d-multiplicities]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_subarray_2d_multiplicities"; - remove_array(array_name); + "[capi][sparse][multi-subarray-2d-multiplicities][rest]") { + std::string array_name = prefix_ + "sparse_multi_subarray_2d_multiplicities"; + create_sparse_array(array_name); write_sparse_array(array_name); @@ -3298,20 +3172,22 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); REQUIRE(error == nullptr); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(config, &ctx) == TILEDB_OK); + tiledb_ctx_free(&ctx_); + tiledb_vfs_free(&vfs_); + // reallocate with input config + vfs_test_init(fs_vec_, &ctx_, &vfs_, config).ok(); + tiledb_config_free(&config); // Open array tiledb_array_t* array; - rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); int a1[20]; uint64_t a1_size = sizeof(a1); @@ -3345,7 +3221,7 @@ TEST_CASE_METHOD( rc = tiledb_query_add_range(ctx_, query, 1, &s11[0], &s11[1], nullptr); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); @@ -3359,41 +3235,32 @@ TEST_CASE_METHOD( CHECK(coords_size == 7 * sizeof(uint64_t)); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-subarray, 2D, incomplete", - "[capi][sparse][multi-subarray-2d-incomplete]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_subarray_2d_incomplete"; - remove_array(array_name); + "[capi][sparse][multi-subarray-2d-incomplete][rest]") { + std::string array_name = prefix_ + "sparse_multi_subarray_2d_incomplete"; + create_sparse_array(array_name); write_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); int a1[3]; uint64_t a1_size = sizeof(a1); @@ -3425,7 +3292,7 @@ TEST_CASE_METHOD( rc = tiledb_query_add_range(ctx_, query, 1, &s11[0], &s11[1], nullptr); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); @@ -3449,7 +3316,7 @@ TEST_CASE_METHOD( CHECK(coords_dim2[1] == 4); } - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); rc = tiledb_query_get_status(ctx_, query, &status); REQUIRE(rc == TILEDB_OK); @@ -3476,41 +3343,32 @@ TEST_CASE_METHOD( } // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-subarray, 2D, complete, col", - "[capi][sparse][multi-subarray-2d-complete-col]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_subarray_2d_complete_col"; - remove_array(array_name); + "[capi][sparse][multi-subarray-2d-complete-col][rest]") { + std::string array_name = prefix_ + "sparse_multi_subarray_2d_complete_col"; + create_sparse_array(array_name, TILEDB_COL_MAJOR); write_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); CHECK(rc == TILEDB_OK); int a1[20]; uint64_t a1_size = sizeof(a1); @@ -3542,7 +3400,7 @@ TEST_CASE_METHOD( rc = tiledb_query_add_range(ctx_, query, 1, &s11[0], &s11[1], nullptr); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx, query); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); tiledb_query_status_t status; rc = tiledb_query_get_status(ctx_, query, &status); @@ -3556,24 +3414,18 @@ TEST_CASE_METHOD( check_counts(span(coords_dim2, 5), {0, 0, 2, 1, 2}); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array 2, multi-range subarray, row-major", - "[capi][sparse][multi-range-row]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_multi_range_row"; - remove_array(array_name); + "[capi][sparse][multi-range-row][rest]") { + std::string array_name = prefix_ + "sparse_multi_range_row"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -3733,18 +3585,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, col-major", - "[capi][sparse][multi-range-col]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_multi_range_col"; - remove_array(array_name); + "[capi][sparse][multi-range-col][rest]") { + std::string array_name = prefix_ + "sparse_multi_range_col"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -3904,18 +3751,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, row-major, incomplete 1", - "[capi][sparse][multi-range-row-incomplete-1]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_range_row_incomplete_1"; - remove_array(array_name); + "[capi][sparse][multi-range-row-incomplete-1][rest]") { + std::string array_name = prefix_ + "sparse_multi_range_row_incomplete_1"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -4095,18 +3937,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, col-major, incomplete 1", - "[capi][sparse][multi-range-col-incomplete-1]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_range_col_incomplete_1"; - remove_array(array_name); + "[capi][sparse][multi-range-col-incomplete-1][rest]") { + std::string array_name = prefix_ + "sparse_multi_range_col_incomplete_1"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -4286,18 +4123,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, row-major, incomplete 2", - "[capi][sparse][multi-range-row-incomplete-2]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_range_row_incomplete_2"; - remove_array(array_name); + "[capi][sparse][multi-range-row-incomplete-2][rest]") { + std::string array_name = prefix_ + "sparse_multi_range_row_incomplete_2"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -4517,18 +4349,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, col-major, incomplete 2", - "[capi][sparse][multi-range-col-incomplete-2]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_range_col_incomplete_2"; - remove_array(array_name); + "[capi][sparse][multi-range-col-incomplete-2][rest]") { + std::string array_name = prefix_ + "sparse_multi_range_col_incomplete_2"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -4748,18 +4575,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, row-major, incomplete 3", - "[capi][sparse][multi-range-row-incomplete-3]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_range_row_incomplete_3"; - remove_array(array_name); + "[capi][sparse][multi-range-row-incomplete-3][rest-fails][sc-43108]") { + std::string array_name = prefix_ + "sparse_multi_range_row_incomplete_3"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -5019,18 +4841,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, row-major, incomplete 4", - "[capi][sparse][multi-range-row-incomplete-4]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_range_row_incomplete_4"; - remove_array(array_name); + "[capi][sparse][multi-range-row-incomplete-4][rest]") { + std::string array_name = prefix_ + "sparse_multi_range_row_incomplete_4"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -5330,18 +5147,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, col-major, incomplete 4", - "[capi][sparse][multi-range-col-incomplete-4]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_range_col_incomplete_4"; - remove_array(array_name); + "[capi][sparse][multi-range-col-incomplete-4][rest]") { + std::string array_name = prefix_ + "sparse_multi_range_col_incomplete_4"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -5641,19 +5453,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, row-major, incomplete 5", - "[capi][sparse][multi-range-row-incomplete-5]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_range_row_incomplete_5"; - remove_array(array_name); - + "[capi][sparse][multi-range-row-incomplete-5][rest-fails][sc-43108]") { + std::string array_name = prefix_ + "sparse_multi_range_row_incomplete_5"; // Create array uint64_t domain[] = {1, 10, 1, 10}; create_sparse_array(array_name, TILEDB_ROW_MAJOR, domain); @@ -5771,18 +5577,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, multi-range subarray, col-major, incomplete 5", - "[capi][sparse][multi-range-col-incomplete-5]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_multi_range_col_incomplete_5"; - remove_array(array_name); + "[capi][sparse][multi-range-col-incomplete-5][rest-fails][sc-43108]") { + std::string array_name = prefix_ + "sparse_multi_range_col_incomplete_5"; // Create array uint64_t domain[] = {1, 10, 1, 10}; @@ -5901,45 +5702,27 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, global order with 0-sized buffers", - "[capi][sparse][global-check][zero-buffers]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_write_global_check"; + "[capi][sparse][global-check][zero-buffers][rest]") { + std::string array_name = prefix_ + "sparse_write_global_check"; create_sparse_array(array_name); - // Create TileDB context - tiledb_ctx_t* ctx = nullptr; - REQUIRE(tiledb_ctx_alloc(nullptr, &ctx) == TILEDB_OK); - // Open array tiledb_array_t* array; - int rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create WRITE query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_GLOBAL_ORDER); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); CHECK(rc == TILEDB_OK); // Prepare attribute buffers @@ -5952,46 +5735,36 @@ TEST_CASE_METHOD( uint64_t zero_size = 0; // Set buffers with zero size - rc = tiledb_query_set_data_buffer(ctx, query, "a1", a1, &zero_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a1", a1, &zero_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx, query, "a2", a2, &zero_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a2", a2, &zero_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_offsets_buffer(ctx, query, "a2", a2_off, &zero_size); + rc = tiledb_query_set_offsets_buffer(ctx_, query, "a2", a2_off, &zero_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx, query, "a3", a3, &zero_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "a3", a3, &zero_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx, query, "d1", coords_dim1, &zero_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "d1", coords_dim1, &zero_size); CHECK(rc == TILEDB_OK); - rc = tiledb_query_set_data_buffer(ctx, query, "d2", coords_dim2, &zero_size); + rc = tiledb_query_set_data_buffer(ctx_, query, "d2", coords_dim2, &zero_size); CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array - CHECK(tiledb_array_close(ctx, array) == TILEDB_OK); + CHECK(tiledb_array_close(ctx_, array) == TILEDB_OK); // Clean up tiledb_query_free(&query); tiledb_array_free(&array); - tiledb_ctx_free(&ctx); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, split coordinate buffers", "[capi][sparse][split-coords]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_split_coords"; + std::string array_name = prefix_ + "sparse_split_coords"; create_sparse_array(array_name); // ---- WRITE ---- @@ -6178,27 +5951,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, split coordinate buffers, global write", - "[capi][sparse][split-coords][global]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_split_coords_global"; + "[capi][sparse][split-coords][global][rest]") { + std::string array_name = prefix_ + "sparse_split_coords_global"; create_sparse_array(array_name); // ---- WRITE ---- @@ -6267,13 +6026,7 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -6335,13 +6088,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); tiledb_query_status_t status; @@ -6393,17 +6140,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, split coordinate buffers, errors", - "[capi][sparse][split-coords][errors]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_split_coords_errors"; + "[capi][sparse][split-coords][errors][rest]") { + std::string array_name = prefix_ + "sparse_split_coords_errors"; create_sparse_array(array_name); // Prepare cell buffers @@ -6578,17 +6321,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, split coordinate buffers for reads", - "[capi][sparse][split-coords][read]") { - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_split_coords_read"; + "[capi][sparse][split-coords][read][rest]") { + std::string array_name = prefix_ + "sparse_split_coords_read"; create_sparse_array(array_name); // ---- WRITE ---- @@ -6775,18 +6514,14 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "C API: Test sparse array, split coordinate buffers for reads, subset of " "dimensions", - "[capi][sparse][split-coords][read][subset]") { - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_split_coords_read_subset"; + "[capi][sparse][split-coords][read][subset][rest]") { + std::string array_name = prefix_ + "sparse_split_coords_read_subset"; create_sparse_array(array_name); // ---- WRITE ---- @@ -6966,28 +6701,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_array(array_name); } TEST_CASE_METHOD( SparseArrayFx, "Sparse array: 2D, multi write global order", - "[capi][sparse][2D][multi-write]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - // Create and write array - SupportedFsLocal local_fs; - std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + - "sparse_split_coords_read_subset"; + "[capi][sparse][2D][multi-write][rest]") { + std::string array_name = prefix_ + "sparse_split_coords_read_subset"; create_sparse_array(array_name); std::vector d1 = {1, 1, 2, 2}; @@ -7055,14 +6775,7 @@ TEST_CASE_METHOD( } // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Create new buffers of smaller size to test being able to write multiple @@ -7118,13 +6831,7 @@ TEST_CASE_METHOD( } // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -7196,7 +6903,7 @@ TEST_CASE_METHOD( SupportedFsLocal local_fs; std::string array_name = local_fs.file_prefix() + local_fs.temp_dir() + "serialize_array_directory"; - remove_array(array_name); + create_sparse_array(array_name); // Write twice (2 fragments) diff --git a/test/src/unit-capi-sparse_heter.cc b/test/src/unit-capi-sparse_heter.cc index efe4de2f195..3d9ce6229a4 100644 --- a/test/src/unit-capi-sparse_heter.cc +++ b/test/src/unit-capi-sparse_heter.cc @@ -61,9 +61,9 @@ struct SparseHeterFx { // Serialization parameters bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; + + // Path to prepend to array name according to filesystem/mode + std::string prefix_; // Functions SparseHeterFx(); @@ -147,9 +147,13 @@ SparseHeterFx::SparseHeterFx() : fs_vec_(vfs_test_get_fs_vec()) { // Initialize vfs test REQUIRE(vfs_test_init(fs_vec_, &ctx_, &vfs_).ok()); + auto temp_dir = fs_vec_[0]->temp_dir(); + create_temp_dir(temp_dir); + prefix_ = vfs_array_uri(fs_vec_[0], temp_dir); } SparseHeterFx::~SparseHeterFx() { + remove_temp_dir(fs_vec_[0]->temp_dir()); // Close vfs test REQUIRE(vfs_test_close(fs_vec_, ctx_, vfs_).ok()); tiledb_vfs_free(&vfs_); @@ -529,13 +533,11 @@ void SparseHeterFx::write_sparse_array_float_int64( REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + if (layout == TILEDB_GLOBAL_ORDER) { + rc = tiledb_query_submit_and_finalize(ctx_, query); + } else { + rc = tiledb_query_submit(ctx_, query); + } REQUIRE(rc == TILEDB_OK); // Close array @@ -578,9 +580,12 @@ void SparseHeterFx::write_sparse_array_int64_float( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, layout); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_submit(ctx_, query); - REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_finalize(ctx_, query); + + if (layout == TILEDB_GLOBAL_ORDER) { + rc = tiledb_query_submit_and_finalize(ctx_, query); + } else { + rc = tiledb_query_submit(ctx_, query); + } REQUIRE(rc == TILEDB_OK); // Close array @@ -723,21 +728,8 @@ void SparseHeterFx::check_read_sparse_array_int64_float( TEST_CASE_METHOD( SparseHeterFx, "C API: Test sparse array with heterogeneous domains (float, int64)", - "[capi][sparse][heter][float-int64]") { - SECTION("- No serialization") { - serialize_ = false; - } - SECTION("- Serialization") { -#ifdef TILEDB_SERIALIZATION - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); -#endif - } - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_array_heter"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][heter][float-int64][non-rest]") { + std::string array_name = prefix_ + "sparse_array_heter"; // Create array float dom_f[] = {1.0f, 20.0f}; @@ -1085,26 +1077,13 @@ TEST_CASE_METHOD( buff_d1_r, buff_d2_r, buff_a_r); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( SparseHeterFx, "C API: Test sparse array with heterogeneous domains (int64, float)", - "[capi][sparse][heter][int64-float]") { - SECTION("- No serialization") { - serialize_ = false; - } - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_array_heter"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][heter][int64-float][non-rest]") { + std::string array_name = prefix_ + "sparse_array_heter"; // Create array float dom_f[] = {1.0f, 20.0f}; @@ -1452,6 +1431,4 @@ TEST_CASE_METHOD( buff_d1_r, buff_d2_r, buff_a_r); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } diff --git a/test/src/unit-capi-sparse_neg.cc b/test/src/unit-capi-sparse_neg.cc index c2e1bdff3e1..de1389a702a 100644 --- a/test/src/unit-capi-sparse_neg.cc +++ b/test/src/unit-capi-sparse_neg.cc @@ -52,14 +52,10 @@ struct SparseNegFx { tiledb_ctx_t* ctx_; tiledb_vfs_t* vfs_; - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; // Vector of supported filsystems const std::vector> fs_vec_; - - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; + // Path to prepend to array name according to filesystem/mode + std::string prefix_; // Functions SparseNegFx(); @@ -80,9 +76,13 @@ SparseNegFx::SparseNegFx() : fs_vec_(vfs_test_get_fs_vec()) { // Initialize vfs test REQUIRE(vfs_test_init(fs_vec_, &ctx_, &vfs_).ok()); + auto temp_dir = fs_vec_[0]->temp_dir(); + create_temp_dir(temp_dir); + prefix_ = vfs_array_uri(fs_vec_[0], temp_dir); } SparseNegFx::~SparseNegFx() { + remove_temp_dir(fs_vec_[0]->temp_dir()); // Close vfs test REQUIRE(vfs_test_close(fs_vec_, ctx_, vfs_).ok()); tiledb_vfs_free(&vfs_); @@ -238,8 +238,7 @@ void SparseNegFx::write_sparse_vector(const std::string& path) { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -317,8 +316,7 @@ void SparseNegFx::read_sparse_vector(const std::string& path) { rc = tiledb_query_set_layout(ctx_, query, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); int a_c[] = {0, 1}; @@ -487,43 +485,22 @@ void SparseNegFx::read_sparse_array_col(const std::string& path) { TEST_CASE_METHOD( SparseNegFx, "C API: Test 1d sparse vector with negative domain", - "[capi][sparse-neg][sparse-neg-vector]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string vector_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_neg_vector"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); - + "[capi][sparse-neg][sparse-neg-vector][rest]") { + std::string vector_name = prefix_ + "sparse_neg_vector"; create_sparse_vector(vector_name); write_sparse_vector(vector_name); read_sparse_vector(vector_name); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( SparseNegFx, "C API: Test 2d sparse array with negative domain", - "[capi][sparse-neg][sparse-neg-array]") { + "[capi][sparse-neg][sparse-neg-array][rest]") { SupportedFsLocal local_fs; - std::string vector_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_neg_array"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); - + std::string vector_name = prefix_ + +"sparse_neg_array"; create_sparse_array(vector_name); write_sparse_array(vector_name); read_sparse_array_global(vector_name); read_sparse_array_row(vector_name); read_sparse_array_col(vector_name); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } diff --git a/test/src/unit-capi-sparse_neg_2.cc b/test/src/unit-capi-sparse_neg_2.cc index f94897dd05e..f11917023a6 100644 --- a/test/src/unit-capi-sparse_neg_2.cc +++ b/test/src/unit-capi-sparse_neg_2.cc @@ -54,12 +54,8 @@ struct SparseNegFx2 { // Vector of supported filsystems const std::vector> fs_vec_; - - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; + // Path to prepend to array name according to filesystem/mode + std::string prefix_; // Functions SparseNegFx2(); @@ -79,9 +75,13 @@ SparseNegFx2::SparseNegFx2() : fs_vec_(vfs_test_get_fs_vec()) { // Initialize vfs test REQUIRE(vfs_test_init(fs_vec_, &ctx_, &vfs_).ok()); + auto temp_dir = fs_vec_[0]->temp_dir(); + create_temp_dir(temp_dir); + prefix_ = vfs_array_uri(fs_vec_[0], temp_dir); } SparseNegFx2::~SparseNegFx2() { + remove_temp_dir(fs_vec_[0]->temp_dir()); // Close vfs test REQUIRE(vfs_test_close(fs_vec_, ctx_, vfs_).ok()); tiledb_vfs_free(&vfs_); @@ -237,8 +237,7 @@ void SparseNegFx2::write_sparse_vector(const std::string& path) { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -319,8 +318,7 @@ void SparseNegFx2::read_sparse_vector(const std::string& path) { REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, path, &query, server_buffers_, serialize_, refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); int a_c[] = {0, 1}; @@ -458,42 +456,22 @@ void SparseNegFx2::read_sparse_array_col(const std::string& path) { TEST_CASE_METHOD( SparseNegFx2, "C API: Test 1d sparse vector with negative domain 2", - "[capi][sparse-neg-2][sparse-neg-vector-2]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string vector_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_neg_vector"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse-neg-2][sparse-neg-vector-2][rest]") { + std::string vector_name = prefix_ + "sparse_neg_vector"; create_sparse_vector(vector_name); write_sparse_vector(vector_name); read_sparse_vector(vector_name); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( SparseNegFx2, "C API: Test 2d sparse array with negative domain 2", - "[capi][sparse-neg-2][sparse-neg-array-2]") { - SupportedFsLocal local_fs; - std::string vector_name = - local_fs.file_prefix() + local_fs.temp_dir() + "sparse_neg_array"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse-neg-2][sparse-neg-array-2][rest]") { + std::string vector_name = prefix_ + +"sparse_neg_array"; create_sparse_array(vector_name); write_sparse_array(vector_name); read_sparse_array_row(vector_name); read_sparse_array_col(vector_name); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } diff --git a/test/src/unit-capi-string.cc b/test/src/unit-capi-string.cc index 3f17621257a..6d56c4da91c 100644 --- a/test/src/unit-capi-string.cc +++ b/test/src/unit-capi-string.cc @@ -33,6 +33,7 @@ #include #include "test/support/src/helpers.h" +#include "test/support/src/vfs_helpers.h" #include "tiledb/sm/c_api/tiledb.h" #include @@ -62,88 +63,84 @@ uint64_t UTF16_OFFSET_2 = sizeof(u"aαbβ") - UTF16_NULL_SIZE; uint64_t UTF16_OFFSET_3 = sizeof(u"aαbβcγ") - UTF16_NULL_SIZE; struct StringFx { - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; - + StringFx(); void create_array(const std::string& array_name); - void delete_array(const std::string& array_name); void read_array(const std::string& array_name); void write_array(const std::string& array_name); + + VFSTestSetup vfs_test_setup_; + tiledb_ctx_t* ctx_; }; +StringFx::StringFx() + : ctx_(vfs_test_setup_.ctx_c) { +} + // Create a simple dense 1D array with three string attributes void StringFx::create_array(const std::string& array_name) { - // Create TileDB context - tiledb_ctx_t* ctx; - int rc = tiledb_ctx_alloc(nullptr, &ctx); - REQUIRE(rc == TILEDB_OK); - // Create dimensions uint64_t dim_domain[] = {1, 4}; uint64_t tile_extent = 2; tiledb_dimension_t* d1; - rc = tiledb_dimension_alloc( - ctx, "d1", TILEDB_UINT64, &dim_domain[0], &tile_extent, &d1); + int rc = tiledb_dimension_alloc( + ctx_, "d1", TILEDB_UINT64, &dim_domain[0], &tile_extent, &d1); REQUIRE(rc == TILEDB_OK); // Create domain tiledb_domain_t* domain; - rc = tiledb_domain_alloc(ctx, &domain); + rc = tiledb_domain_alloc(ctx_, &domain); REQUIRE(rc == TILEDB_OK); - rc = tiledb_domain_add_dimension(ctx, domain, d1); + rc = tiledb_domain_add_dimension(ctx_, domain, d1); REQUIRE(rc == TILEDB_OK); // Create fixed-sized UTF-8 attribute tiledb_attribute_t* a1; - rc = tiledb_attribute_alloc(ctx, "a1", TILEDB_STRING_ASCII, &a1); + rc = tiledb_attribute_alloc(ctx_, "a1", TILEDB_STRING_ASCII, &a1); REQUIRE(rc == TILEDB_OK); - rc = tiledb_attribute_set_cell_val_num(ctx, a1, 2); + rc = tiledb_attribute_set_cell_val_num(ctx_, a1, 2); REQUIRE(rc == TILEDB_OK); // Create variable-sized UTF-8 attribute tiledb_attribute_t* a2; - rc = tiledb_attribute_alloc(ctx, "a2", TILEDB_STRING_UTF8, &a2); + rc = tiledb_attribute_alloc(ctx_, "a2", TILEDB_STRING_UTF8, &a2); REQUIRE(rc == TILEDB_OK); - rc = tiledb_attribute_set_cell_val_num(ctx, a2, TILEDB_VAR_NUM); + rc = tiledb_attribute_set_cell_val_num(ctx_, a2, TILEDB_VAR_NUM); REQUIRE(rc == TILEDB_OK); - rc = set_attribute_compression_filter(ctx, a2, TILEDB_FILTER_GZIP, -1); + rc = set_attribute_compression_filter(ctx_, a2, TILEDB_FILTER_GZIP, -1); REQUIRE(rc == TILEDB_OK); // Create variable-sized UTF-16 attribute tiledb_attribute_t* a3; - rc = tiledb_attribute_alloc(ctx, "a3", TILEDB_STRING_UTF16, &a3); + rc = tiledb_attribute_alloc(ctx_, "a3", TILEDB_STRING_UTF16, &a3); REQUIRE(rc == TILEDB_OK); - rc = tiledb_attribute_set_cell_val_num(ctx, a3, TILEDB_VAR_NUM); + rc = tiledb_attribute_set_cell_val_num(ctx_, a3, TILEDB_VAR_NUM); REQUIRE(rc == TILEDB_OK); - rc = set_attribute_compression_filter(ctx, a3, TILEDB_FILTER_ZSTD, -1); + rc = set_attribute_compression_filter(ctx_, a3, TILEDB_FILTER_ZSTD, -1); REQUIRE(rc == TILEDB_OK); // Create array schema tiledb_array_schema_t* array_schema; - rc = tiledb_array_schema_alloc(ctx, TILEDB_DENSE, &array_schema); + rc = tiledb_array_schema_alloc(ctx_, TILEDB_DENSE, &array_schema); REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_cell_order(ctx, array_schema, TILEDB_ROW_MAJOR); + rc = tiledb_array_schema_set_cell_order(ctx_, array_schema, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_tile_order(ctx, array_schema, TILEDB_ROW_MAJOR); + rc = tiledb_array_schema_set_tile_order(ctx_, array_schema, TILEDB_ROW_MAJOR); REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_set_domain(ctx, array_schema, domain); + rc = tiledb_array_schema_set_domain(ctx_, array_schema, domain); REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_add_attribute(ctx, array_schema, a1); + rc = tiledb_array_schema_add_attribute(ctx_, array_schema, a1); REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_add_attribute(ctx, array_schema, a2); + rc = tiledb_array_schema_add_attribute(ctx_, array_schema, a2); REQUIRE(rc == TILEDB_OK); - rc = tiledb_array_schema_add_attribute(ctx, array_schema, a3); + rc = tiledb_array_schema_add_attribute(ctx_, array_schema, a3); REQUIRE(rc == TILEDB_OK); // Check array schema - rc = tiledb_array_schema_check(ctx, array_schema); + rc = tiledb_array_schema_check(ctx_, array_schema); REQUIRE(rc == TILEDB_OK); // Create array - rc = tiledb_array_create(ctx, array_name.c_str(), array_schema); + rc = tiledb_array_create(ctx_, array_name.c_str(), array_schema); REQUIRE(rc == TILEDB_OK); // Clean up @@ -153,15 +150,9 @@ void StringFx::create_array(const std::string& array_name) { tiledb_dimension_free(&d1); tiledb_domain_free(&domain); tiledb_array_schema_free(&array_schema); - tiledb_ctx_free(&ctx); } void StringFx::write_array(const std::string& array_name) { - // Create TileDB context - tiledb_ctx_t* ctx; - int rc = tiledb_ctx_alloc(nullptr, &ctx); - REQUIRE(rc == TILEDB_OK); - // Prepare buffers void* buffer_a1 = std::malloc(sizeof(UTF8_STRINGS) - UTF8_NULL_SIZE); uint64_t buffer_a2_offsets[] = { @@ -188,68 +179,56 @@ void StringFx::write_array(const std::string& array_name) { // Open array tiledb_array_t* array; - rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_WRITE); + rc = tiledb_array_open(ctx_, array, TILEDB_WRITE); CHECK(rc == TILEDB_OK); // Create query tiledb_query_t* query; const char* attributes[] = {"a1", "a2", "a3"}; - rc = tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_WRITE, &query); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_GLOBAL_ORDER); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[0], buffers[0], &buffer_sizes[0]); + ctx_, query, attributes[0], buffers[0], &buffer_sizes[0]); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[1], buffers[2], &buffer_sizes[2]); + ctx_, query, attributes[1], buffers[2], &buffer_sizes[2]); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); + ctx_, query, attributes[1], (uint64_t*)buffers[1], &buffer_sizes[1]); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, attributes[2], buffers[4], &buffer_sizes[4]); + ctx_, query, attributes[2], buffers[4], &buffer_sizes[4]); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, query, attributes[2], (uint64_t*)buffers[3], &buffer_sizes[3]); + ctx_, query, attributes[2], (uint64_t*)buffers[3], &buffer_sizes[3]); REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - tiledb_ctx_free(&ctx); std::free(buffer_a1); std::free(buffer_a2); std::free(buffer_a3); } void StringFx::read_array(const std::string& array_name) { - // Create TileDB context - tiledb_ctx_t* ctx; - int rc = tiledb_ctx_alloc(nullptr, &ctx); - REQUIRE(rc == TILEDB_OK); - // Open array tiledb_array_t* array; - rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + int rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Compute max buffer sizes @@ -269,36 +248,30 @@ void StringFx::read_array(const std::string& array_name) { // Create query tiledb_query_t* query; - rc = tiledb_query_alloc(ctx, array, TILEDB_READ, &query); + rc = tiledb_query_alloc(ctx_, array, TILEDB_READ, &query); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, "a1", buffer_a1, &buffer_a1_size); + ctx_, query, "a1", buffer_a1, &buffer_a1_size); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, "a2", buffer_a2_val, &buffer_a2_val_size); + ctx_, query, "a2", buffer_a2_val, &buffer_a2_val_size); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, query, "a2", buffer_a2_off, &buffer_a2_off_size); + ctx_, query, "a2", buffer_a2_off, &buffer_a2_off_size); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_data_buffer( - ctx, query, "a3", buffer_a3_val, &buffer_a3_val_size); + ctx_, query, "a3", buffer_a3_val, &buffer_a3_val_size); REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_offsets_buffer( - ctx, query, "a3", buffer_a3_off, &buffer_a3_off_size); + ctx_, query, "a3", buffer_a3_off, &buffer_a3_off_size); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_set_layout(ctx, query, TILEDB_GLOBAL_ORDER); + rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); REQUIRE(rc == TILEDB_OK); - rc = tiledb_query_set_subarray(ctx, query, subarray); + rc = tiledb_query_set_subarray(ctx_, query, subarray); CHECK(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Check results @@ -320,13 +293,12 @@ void StringFx::read_array(const std::string& array_name) { CHECK(buffer_a3_off[3] == UTF16_OFFSET_3); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - tiledb_ctx_free(&ctx); std::free(buffer_a1); std::free(buffer_a2_off); std::free(buffer_a2_val); @@ -334,40 +306,10 @@ void StringFx::read_array(const std::string& array_name) { std::free(buffer_a3_val); } -void StringFx::delete_array(const std::string& array_name) { - // Create TileDB context - tiledb_ctx_t* ctx; - int rc = tiledb_ctx_alloc(nullptr, &ctx); - REQUIRE(rc == TILEDB_OK); - - // Remove array - tiledb_object_t type; - rc = tiledb_object_type(ctx, array_name.c_str(), &type); - REQUIRE(rc == TILEDB_OK); - if (type == TILEDB_ARRAY) { - rc = tiledb_object_remove(ctx, array_name.c_str()); - REQUIRE(rc == TILEDB_OK); - } - - // Clean up - tiledb_ctx_free(&ctx); -} - -TEST_CASE_METHOD(StringFx, "C API: Test string support", "[capi][string]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - std::string array_name = "foo"; - delete_array(array_name); +TEST_CASE_METHOD( + StringFx, "C API: Test string support", "[capi][string][rest]") { + std::string array_name = vfs_test_setup_.array_uri("foo"); create_array(array_name); write_array(array_name); read_array(array_name); - delete_array(array_name); } diff --git a/test/src/unit-capi-string_dims.cc b/test/src/unit-capi-string_dims.cc index e2d3135ebd9..0b9e7c6fad2 100644 --- a/test/src/unit-capi-string_dims.cc +++ b/test/src/unit-capi-string_dims.cc @@ -58,14 +58,13 @@ struct StringDimsFx { tiledb_ctx_t* ctx_; tiledb_vfs_t* vfs_; - // Vector of supported filsystems - const std::vector> fs_vec_; - // Serialization parameters bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - tiledb::test::ServerQueryBuffers server_buffers_; + + // Vector of supported filsystems + const std::vector> fs_vec_; + // Path to prepend to array name according to filesystem/mode + std::string prefix_; // Used to get the number of directories or files of another directory struct get_num_struct { @@ -179,9 +178,13 @@ StringDimsFx::StringDimsFx() : fs_vec_(vfs_test_get_fs_vec()) { // Initialize vfs test REQUIRE(vfs_test_init(fs_vec_, &ctx_, &vfs_).ok()); + auto temp_dir = fs_vec_[0]->temp_dir(); + create_temp_dir(temp_dir); + prefix_ = vfs_array_uri(fs_vec_[0], temp_dir); } StringDimsFx::~StringDimsFx() { + remove_temp_dir(fs_vec_[0]->temp_dir()); // Close vfs test REQUIRE(vfs_test_close(fs_vec_, ctx_, vfs_).ok()); tiledb_vfs_free(&vfs_); @@ -368,13 +371,11 @@ void StringDimsFx::write_array_1d( REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + if (layout == TILEDB_GLOBAL_ORDER) { + rc = tiledb_query_submit_and_finalize(ctx, query); + } else { + rc = tiledb_query_submit(ctx, query); + } CHECK(rc == TILEDB_OK); // Close array @@ -425,13 +426,11 @@ void StringDimsFx::write_array_2d( REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + if (layout == TILEDB_GLOBAL_ORDER) { + rc = tiledb_query_submit_and_finalize(ctx, query); + } else { + rc = tiledb_query_submit(ctx, query); + } CHECK(rc == TILEDB_OK); // Close array @@ -716,14 +715,7 @@ void StringDimsFx::read_array_1d( rc = tiledb_array_get_uri(ctx, array, &array_uri); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx, query); CHECK(rc == TILEDB_OK); // Get status @@ -837,14 +829,7 @@ void StringDimsFx::read_array_2d( const char* array_uri; rc = tiledb_array_get_uri(ctx, array, &array_uri); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx, query); CHECK(rc == TILEDB_OK); // Get status @@ -904,14 +889,7 @@ void StringDimsFx::read_array_2d_default_string_range( const char* array_uri; rc = tiledb_array_get_uri(ctx, array, &array_uri); CHECK(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx, - array_uri, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx, query); CHECK(rc == TILEDB_OK); // Get status @@ -931,21 +909,8 @@ void StringDimsFx::read_array_2d_default_string_range( TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, array schema", - "[capi][sparse][string-dims][array-schema]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][array-schema][rest]") { + std::string array_name = prefix_ + "string_dims"; // Create dimension tiledb_domain_t* domain; @@ -1035,29 +1000,14 @@ TEST_CASE_METHOD( tiledb_array_schema_free(&array_schema); tiledb_domain_free(&domain); tiledb_dimension_free(&d); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, check duplicates, global " "order", - "[capi][sparse][string-dims][duplicates][global]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][duplicates][global][rest]") { + std::string array_name = prefix_ + "string_dims"; create_array( ctx_, @@ -1102,14 +1052,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); REQUIRE(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_ERR); // Close array @@ -1119,29 +1062,14 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, check duplicates, " "unordered", - "[capi][sparse][string-dims][duplicates][unordered]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][duplicates][unordered][rest]") { + std::string array_name = prefix_ + +"string_dims"; create_array( ctx_, @@ -1187,14 +1115,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); REQUIRE(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_ERR); // Close array @@ -1204,29 +1125,14 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, check global order " "violation", - "[capi][sparse][string-dims][global-order][violation]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][global-order][violation][rest]") { + std::string array_name = prefix_ + "string_dims"; create_array( ctx_, @@ -1272,14 +1178,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_GLOBAL_ORDER); REQUIRE(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_ERR); // Close array @@ -1289,28 +1188,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, errors", - "[capi][sparse][string-dims][errors]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][errors][rest-fails][sc-43167]") { + std::string array_name = prefix_ + "string_dims"; // Create array create_array( @@ -1359,14 +1243,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); rc = tiledb_query_set_layout(ctx_, query, TILEDB_UNORDERED); REQUIRE(rc == TILEDB_OK); - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); REQUIRE(rc == TILEDB_OK); // Close array @@ -1402,7 +1279,7 @@ TEST_CASE_METHOD( ctx_, query, TILEDB_COORDS, buff, &buff_size); REQUIRE(rc == TILEDB_ERR); int data[1]; - uint64_t data_size; + uint64_t data_size = 4; rc = tiledb_query_set_data_buffer(ctx_, query, "d", data, &data_size); REQUIRE(rc == TILEDB_OK); @@ -1419,28 +1296,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); tiledb_query_free(&query); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, 1d", - "[capi][sparse][string-dims][1d][basic]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][1d][basic][rest]") { + std::string array_name = prefix_ + "string_dims"; // Create array create_array( @@ -1662,28 +1524,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, 1d, consolidation", - "[capi][sparse][string-dims][1d][consolidation]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][1d][consolidation][non-rest]") { + std::string array_name = prefix_ + "string_dims"; // Create array create_array( @@ -1853,28 +1700,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, 1d, allow duplicates", - "[capi][sparse][string-dims][1d][allow-dups]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][1d][allow-dups][rest]") { + std::string array_name = prefix_ + "string_dims"; // Create array create_array( @@ -1968,28 +1800,13 @@ TEST_CASE_METHOD( // Clean up tiledb_array_free(&array); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, 1d, dedup", - "[capi][sparse][string-dims][1d][dedup]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][1d][dedup][rest]") { + std::string array_name = prefix_ + "string_dims"; // Create array create_array( @@ -2019,16 +1836,17 @@ TEST_CASE_METHOD( rc = tiledb_config_set(config, "sm.dedup_coords", "true", &error); CHECK(rc == TILEDB_OK); - // Create context - tiledb_ctx_t* ctx; - rc = tiledb_ctx_alloc(config, &ctx); - CHECK(rc == TILEDB_OK); + tiledb_ctx_free(&ctx_); + tiledb_vfs_free(&vfs_); + // reallocate with input config + vfs_test_init(fs_vec_, &ctx_, &vfs_, config).ok(); + tiledb_config_free(&config); // Write std::vector d_off = {0, 2, 4, 8}; std::string d_val("ccccddddaa"); std::vector a = {2, 3, 4, 1}; - write_array_1d(ctx, array_name, TILEDB_UNORDERED, d_off, d_val, a); + write_array_1d(ctx_, array_name, TILEDB_UNORDERED, d_off, d_val, a); // Clean up tiledb_config_free(&config); @@ -2037,9 +1855,9 @@ TEST_CASE_METHOD( // Open array tiledb_array_t* array; - rc = tiledb_array_alloc(ctx, array_name.c_str(), &array); + rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx, array, TILEDB_READ); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); CHECK(rc == TILEDB_OK); // Check non-empty domain @@ -2073,7 +1891,7 @@ TEST_CASE_METHOD( tiledb_query_status_t status; tiledb_query_status_details_t details; read_array_1d( - ctx, + ctx_, array, layout, "a", @@ -2094,34 +1912,18 @@ TEST_CASE_METHOD( CHECK(c_a_matches); // Close array - rc = tiledb_array_close(ctx, array); + rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); // Clean up tiledb_array_free(&array); - tiledb_ctx_free(&ctx); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, 2d", - "[capi][sparse][string-dims][2d]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][2d][rest]") { + std::string array_name = prefix_ + "string_dims"; // Create array int32_t dom[] = {1, 10}; @@ -2323,77 +2125,66 @@ TEST_CASE_METHOD( CHECK(rc == TILEDB_OK); tiledb_array_free(&array); - rc = tiledb_config_set(config, "sm.consolidation.mode", "fragments", &error); - CHECK(rc == TILEDB_OK); - - // Consolidate - rc = tiledb_array_consolidate(ctx_, array_name.c_str(), config); - CHECK(rc == TILEDB_OK); - rc = tiledb_array_vacuum(ctx_, array_name.c_str(), nullptr); - CHECK(rc == TILEDB_OK); - - // Open array - rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); - CHECK(rc == TILEDB_OK); - rc = tiledb_array_open(ctx_, array, TILEDB_READ); - CHECK(rc == TILEDB_OK); - - // Read [a, ff], [1, 10] - r_d1_off.resize(20); - r_d1_val.resize(20); - r_d2.resize(20); - r_a.resize(20); - read_array_2d( - ctx_, - array, - TILEDB_GLOBAL_ORDER, - "a", - "ff", - 1, - 10, - &r_d1_off, - &r_d1_val, - &r_d2, - &r_a, - &status); - CHECK(status == TILEDB_COMPLETED); - CHECK(r_d1_val == "aaabbbccddddff"); - c_d1_off = {0, 1, 3, 4, 6, 8, 12}; - CHECK(r_d1_off == c_d1_off); - c_d2 = {2, 1, 2, 2, 3, 4, 3}; - CHECK(r_d2 == c_d2); - c_a = {15, 11, 16, 12, 13, 14, 17}; - CHECK(r_a == c_a); - - // Close array - rc = tiledb_array_close(ctx_, array); - CHECK(rc == TILEDB_OK); - - // Clean up - tiledb_array_free(&array); - tiledb_config_free(&config); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + if (!fs_vec_[0]->is_rest()) { + rc = + tiledb_config_set(config, "sm.consolidation.mode", "fragments", &error); + CHECK(rc == TILEDB_OK); + + // Consolidate + rc = tiledb_array_consolidate(ctx_, array_name.c_str(), config); + CHECK(rc == TILEDB_OK); + rc = tiledb_array_vacuum(ctx_, array_name.c_str(), nullptr); + CHECK(rc == TILEDB_OK); + + // Open array + rc = tiledb_array_alloc(ctx_, array_name.c_str(), &array); + CHECK(rc == TILEDB_OK); + rc = tiledb_array_open(ctx_, array, TILEDB_READ); + CHECK(rc == TILEDB_OK); + + // Read [a, ff], [1, 10] + r_d1_off.resize(20); + r_d1_val.resize(20); + r_d2.resize(20); + r_a.resize(20); + read_array_2d( + ctx_, + array, + TILEDB_GLOBAL_ORDER, + "a", + "ff", + 1, + 10, + &r_d1_off, + &r_d1_val, + &r_d2, + &r_a, + &status); + CHECK(status == TILEDB_COMPLETED); + CHECK(r_d1_val == "aaabbbccddddff"); + c_d1_off = {0, 1, 3, 4, 6, 8, 12}; + CHECK(r_d1_off == c_d1_off); + c_d2 = {2, 1, 2, 2, 3, 4, 3}; + CHECK(r_d2 == c_d2); + c_a = {15, 11, 16, 12, 13, 14, 17}; + CHECK(r_a == c_a); + + // Close array + rc = tiledb_array_close(ctx_, array); + CHECK(rc == TILEDB_OK); + + // Clean up + tiledb_array_free(&array); + tiledb_config_free(&config); + } } TEST_CASE_METHOD( StringDimsFx, "C API: Test multiple var size global writes 1", - "[capi][sparse][var-size][multiple-global-writes-1]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][var-size][multiple-global-writes-1][rest-fails][sc-" + "43168]") { + std::string array_name = prefix_ + "string_dims"; create_array( ctx_, @@ -2441,14 +2232,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Write "b, 2" @@ -2456,13 +2240,7 @@ TEST_CASE_METHOD( a_data[0] = 2; // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -2508,28 +2286,14 @@ TEST_CASE_METHOD( rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); tiledb_array_free(&array); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test multiple var size global writes 2", - "[capi][sparse][var-size][multiple-global-writes-2]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][var-size][multiple-global-writes-2][rest-fails][sc-" + "43168]") { + std::string array_name = prefix_ + "string_dims"; create_array( ctx_, @@ -2577,14 +2341,7 @@ TEST_CASE_METHOD( REQUIRE(rc == TILEDB_OK); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Write "b, 2" @@ -2592,14 +2349,7 @@ TEST_CASE_METHOD( a_data[0] = 2; // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); + rc = tiledb_query_submit(ctx_, query); CHECK(rc == TILEDB_OK); // Write c, 3; d, 4 and e, 5. @@ -2614,13 +2364,7 @@ TEST_CASE_METHOD( a_size = 3 * sizeof(int32_t); // Submit query - rc = submit_query_wrapper( - ctx_, - array_name, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); + rc = tiledb_query_submit_and_finalize(ctx_, query); CHECK(rc == TILEDB_OK); // Close array @@ -2666,28 +2410,13 @@ TEST_CASE_METHOD( rc = tiledb_array_close(ctx_, array); CHECK(rc == TILEDB_OK); tiledb_array_free(&array); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } TEST_CASE_METHOD( StringDimsFx, "C API: Test sparse array with string dimensions, 2d, default ranges", - "[capi][sparse][string-dims][2d][default-ranges]") { - SECTION("- No serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("- Serialization") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - - SupportedFsLocal local_fs; - std::string array_name = - local_fs.file_prefix() + local_fs.temp_dir() + "string_dims"; - create_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); + "[capi][sparse][string-dims][2d][default-ranges][rest]") { + std::string array_name = prefix_ + "string_dims"; // Create array int32_t dom[] = {1, 10}; @@ -2848,6 +2577,4 @@ TEST_CASE_METHOD( // Clean up tiledb_config_free(&config); - - remove_temp_dir(local_fs.file_prefix() + local_fs.temp_dir()); } diff --git a/test/src/unit-cppapi-consolidation-with-timestamps.cc b/test/src/unit-cppapi-consolidation-with-timestamps.cc index 4f6d614775b..cfb8e0de257 100644 --- a/test/src/unit-cppapi-consolidation-with-timestamps.cc +++ b/test/src/unit-cppapi-consolidation-with-timestamps.cc @@ -53,12 +53,6 @@ struct ConsolidationWithTimestampsFx { VFS vfs_; sm::StorageManager* sm_; - // Serialization parameters - bool serialize_ = false; - bool refactored_query_v2_ = false; - // Buffers to allocate on server side for serialized queries - ServerQueryBuffers server_buffers_; - // Constructors/destructors. ConsolidationWithTimestampsFx(); ~ConsolidationWithTimestampsFx(); @@ -183,14 +177,7 @@ void ConsolidationWithTimestampsFx::write_sparse( query.set_data_buffer("d2", dim2); // Submit query - auto rc = test::submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); - REQUIRE(rc == TILEDB_OK); + query.submit_and_finalize(); // Close array. array.close(); @@ -220,14 +207,7 @@ void ConsolidationWithTimestampsFx::write_sparse_v11(uint64_t timestamp) { query.set_data_buffer("d2", buffer_coords_dim2); // Submit query - auto rc = test::submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_); - REQUIRE(rc == TILEDB_OK); + query.submit_and_finalize(); // Close array. array.close(); @@ -323,15 +303,7 @@ void ConsolidationWithTimestampsFx::read_sparse( } // Submit the query. - auto rc = test::submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); - REQUIRE(rc == TILEDB_OK); + query.submit(); CHECK(query.query_status() == Query::Status::COMPLETE); // Get the query stats. @@ -367,15 +339,7 @@ void ConsolidationWithTimestampsFx::reopen_sparse( } // Submit the query. - auto rc = test::submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); - REQUIRE(rc == TILEDB_OK); + query.submit(); CHECK(query.query_status() == Query::Status::COMPLETE); // Get the query stats. @@ -404,17 +368,7 @@ bool ConsolidationWithTimestampsFx::is_array(const std::string& array_name) { TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps", - "[cppapi][consolidation-with-timestamps][write-check]") { - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[cppapi][consolidation-with-timestamps][write-check][non-rest]") { remove_sparse_array(); create_sparse_array(); @@ -441,19 +395,11 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, check directory contents", - "[cppapi][consolidation-with-timestamps][sparse-unordered-with-dups]") { + "[cppapi][consolidation-with-timestamps][sparse-unordered-with-dups][non-" + "rest]") { remove_sparse_array(); create_sparse_array(true); - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); @@ -505,14 +451,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, global read", - "[cppapi][consolidation-with-timestamps][global-read]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(false, true); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[cppapi][consolidation-with-timestamps][global-read][non-rest]") { remove_sparse_array(); create_sparse_array(); @@ -559,21 +498,12 @@ TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, check directory contents of " "old array", - "[cppapi][consolidation-with-timestamps][sparse-unordered-with-dups]") { + "[cppapi][consolidation-with-timestamps][sparse-unordered-with-dups][non-" + "rest]") { if constexpr (is_experimental_build) { return; } - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif - remove_sparse_array(); create_sparse_array_v11(); // Write first fragment. @@ -629,14 +559,8 @@ TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, global read, all cells same " "coords", - "[cppapi][consolidation-with-timestamps][global-read][same-coords]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(false, true); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[cppapi][consolidation-with-timestamps][global-read][same-coords][non-" + "rest]") { remove_sparse_array(); create_sparse_array(); @@ -675,14 +599,8 @@ TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, global read, same coords " "across tiles", - "[cppapi][consolidation-with-timestamps][global-read][across-tiles]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(false, true); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[cppapi][consolidation-with-timestamps][global-read][across-tiles][non-" + "rest]") { remove_sparse_array(); bool allow_dups = GENERATE(true, false); create_sparse_array(allow_dups); @@ -738,19 +656,10 @@ TEST_CASE_METHOD( "CPP API: Test consolidation with timestamps, global read, all cells same " "coords, with memory budget", "[cppapi][consolidation-with-timestamps][global-read][same-coords][mem-" - "budget]") { + "budget][non-rest]") { remove_sparse_array(); create_sparse_array(); - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif // Write fragments. for (uint64_t i = 0; i < 50; i++) { std::vector a(1); @@ -791,19 +700,10 @@ TEST_CASE_METHOD( "CPP API: Test consolidation with timestamps, global read, same cells " "across tiles, with memory budget", "[cppapi][consolidation-with-timestamps][global-read][across-tiles][mem-" - "budget]") { + "budget][non-rest]") { remove_sparse_array(); create_sparse_array(); - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif // Write fragments. // We write 8 cells per fragment for 6 fragments. Then it gets consolidated // into one. So we'll get in order 6xcell1, 6xcell2... total 48 cells. Tile @@ -851,18 +751,11 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, partial read with dups", - "[cppapi][consolidation-with-timestamps][partial-read][dups]") { + "[cppapi][consolidation-with-timestamps][partial-read][dups][non-rest]") { remove_sparse_array(); // Enable duplicates. create_sparse_array(true); -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); @@ -945,18 +838,12 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, partial read without dups", - "[cppapi][consolidation-with-timestamps][partial-read][no-dups]") { + "[cppapi][consolidation-with-timestamps][partial-read][no-dups][non-" + "rest]") { remove_sparse_array(); // No duplicates. create_sparse_array(); -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); @@ -1024,18 +911,11 @@ TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, full and partial read with " "dups", - "[cppapi][consolidation-with-timestamps][partial-read][dups]") { + "[cppapi][consolidation-with-timestamps][partial-read][dups][non-rest]") { remove_sparse_array(); // Enable duplicates. create_sparse_array(true); -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); // Write second fragment. @@ -1177,18 +1057,11 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, reopen", - "[cppapi][consolidation-with-timestamps][partial-read][dups]") { + "[cppapi][consolidation-with-timestamps][partial-read][dups][non-rest]") { remove_sparse_array(); // Enable duplicates. create_sparse_array(true); -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); // Write second fragment. @@ -1292,18 +1165,11 @@ TEST_CASE_METHOD( "CPP API: Test read timestamps of unconsolidated fragments, unordered " "reader", "[cppapi][consolidation-with-timestamps][read-timestamps][unordered-" - "reader]") { + "reader][non-rest]") { remove_sparse_array(); // Enable duplicates. create_sparse_array(true); -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); // Write second fragment. @@ -1392,7 +1258,7 @@ TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test read timestamps, unordered reader, overlapping ranges", "[cppapi][consolidation-with-timestamps][read-timestamps][unordered-" - "reader][overlapping-ranges][SC-18541]") { + "reader][overlapping-ranges][SC-18541][non-rest]") { remove_sparse_array(); // Enable duplicates. create_sparse_array(true); @@ -1409,15 +1275,6 @@ TEST_CASE_METHOD( sm_ = ctx_.ptr().get()->storage_manager(); vfs_ = VFS(ctx_); - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); // Write second fragment. @@ -1456,15 +1313,7 @@ TEST_CASE_METHOD( query.add_range(1, 2, 3); // Submit/finalize the query - auto rc = test::submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); - REQUIRE(rc == TILEDB_OK); + query.submit(); CHECK(query.query_status() == Query::Status::COMPLETE); // Expect to read what the first 2 writes wrote: each element will @@ -1522,18 +1371,11 @@ TEST_CASE_METHOD( "CPP API: Test read timestamps of unconsolidated fragments, global order " "reader", "[cppapi][consolidation-with-timestamps][read-timestamps][global-order-" - "reader]") { + "reader][non-rest]") { remove_sparse_array(); // Enable duplicates. create_sparse_array(true); -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(true, false); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); // Write second fragment. @@ -1632,7 +1474,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, check number of tiles read", - "[cppapi][consolidation-with-timestamps][partial-read][stats]") { + "[cppapi][consolidation-with-timestamps][partial-read][stats][non-rest]") { remove_sparse_array(); // Enable duplicates. create_sparse_array(true); @@ -1718,15 +1560,6 @@ TEST_CASE_METHOD( remove_sparse_array(); create_sparse_array(false); - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); // Write second fragment. @@ -1746,15 +1579,6 @@ TEST_CASE_METHOD( remove_sparse_array(); create_sparse_array(false); - SECTION("no serialization") { - serialize_ = false; - } -#ifdef TILEDB_SERIALIZATION - SECTION("serialization enabled global order write") { - serialize_ = true; - refactored_query_v2_ = GENERATE(true, false); - } -#endif // Write first fragment. write_sparse({0, 1, 2, 3}, {1, 1, 1, 2}, {1, 2, 4, 3}, 1); // Write second fragment. @@ -1785,14 +1609,8 @@ TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, consolidate consolidated" " fragment with timestamps", - "[cppapi][consolidation-with-timestamps][frag-w-timestamps]") { + "[cppapi][consolidation-with-timestamps][frag-w-timestamps][non-rest]") { remove_sparse_array(); -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(false, true); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif bool dups = GENERATE(true, false); @@ -1869,14 +1687,7 @@ TEST_CASE_METHOD( TEST_CASE_METHOD( ConsolidationWithTimestampsFx, "CPP API: Test consolidation with timestamps, ts tiles kept in memory", - "[cppapi][consolidation-with-timestamps][ts-tile-in-memory]") { -#ifdef TILEDB_SERIALIZATION - serialize_ = GENERATE(false, true); - if (serialize_) { - refactored_query_v2_ = GENERATE(true, false); - } -#endif - + "[cppapi][consolidation-with-timestamps][ts-tile-in-memory][non-rest]") { remove_sparse_array(); // Enable duplicates. @@ -1908,15 +1719,7 @@ TEST_CASE_METHOD( query.set_data_buffer(tiledb_timestamps(), timestamps); // Submit the query. - auto rc = test::submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); - REQUIRE(rc == TILEDB_OK); + query.submit(); CHECK(query.query_status() == Query::Status::INCOMPLETE); // Validate. @@ -1931,15 +1734,7 @@ TEST_CASE_METHOD( !memcmp(c_ts.data(), timestamps.data(), c_ts.size() * sizeof(uint64_t))); // Submit again. - rc = test::submit_query_wrapper( - ctx_, - SPARSE_ARRAY_NAME, - &query, - server_buffers_, - serialize_, - refactored_query_v2_, - false); - REQUIRE(rc == TILEDB_OK); + query.submit(); CHECK(query.query_status() == Query::Status::COMPLETE); // Validate. diff --git a/test/src/unit-cppapi-string-dims.cc b/test/src/unit-cppapi-string-dims.cc index abc7e961a17..d865dc8dbca 100644 --- a/test/src/unit-cppapi-string-dims.cc +++ b/test/src/unit-cppapi-string-dims.cc @@ -32,6 +32,7 @@ #include #include "test/support/src/helpers.h" +#include "test/support/src/vfs_helpers.h" #include "tiledb/sm/cpp_api/tiledb" #include "tiledb/common/logger_public.h" @@ -1451,25 +1452,17 @@ void write_sparse_array_string_dim( const std::string& array_name, std::string& data, std::vector& data_offsets, - tiledb_layout_t layout, - const bool serialized, - const bool refactored_query_v2) { + tiledb_layout_t layout) { Array array(ctx, array_name, TILEDB_WRITE); Query query(ctx, array, TILEDB_WRITE); query.set_layout(layout); query.set_data_buffer("dim1", (char*)data.data(), data.size()); query.set_offsets_buffer("dim1", data_offsets.data(), data_offsets.size()); - - // Submit query - test::ServerQueryBuffers server_buffers_; - auto rc = test::submit_query_wrapper( - ctx, - array_name, - &query, - server_buffers_, - serialized, - refactored_query_v2); - REQUIRE(rc == TILEDB_OK); + if (layout != TILEDB_GLOBAL_ORDER) { + query.submit(); + } else { + query.submit_and_finalize(); + } array.close(); } @@ -1479,9 +1472,7 @@ void read_and_check_sparse_array_string_dim( const std::string& array_name, std::string& expected_data, std::vector& expected_offsets, - tiledb_layout_t layout, - const bool serialized, - const bool refactored_query_v2) { + tiledb_layout_t layout) { Array array(ctx, array_name, TILEDB_READ); std::vector offsets_back(expected_offsets.size()); @@ -1494,16 +1485,7 @@ void read_and_check_sparse_array_string_dim( query.set_offsets_buffer("dim1", offsets_back.data(), offsets_back.size()); query.set_layout(layout); - // Submit query - test::ServerQueryBuffers server_buffers_; - auto rc = test::submit_query_wrapper( - ctx, - array_name, - &query, - server_buffers_, - serialized, - refactored_query_v2); - REQUIRE(rc == TILEDB_OK); + query.submit(); // Check the element data and offsets are properly returned CHECK(data_back == expected_data); @@ -1514,16 +1496,7 @@ void read_and_check_sparse_array_string_dim( TEST_CASE( "C++ API: Test filtering of string dimensions on sparse arrays", - "[cppapi][string-dims][rle-strings][dict-strings][sparse]") { - std::string array_name = "test_rle_string_dim"; - bool serialized = false, refactored_query_v2 = false; -#ifdef TILEDB_SERIALIZATION - serialized = GENERATE(true, false); - if (serialized) { - refactored_query_v2 = GENERATE(true, false); - } -#endif - + "[cppapi][string-dims][rle-strings][dict-strings][sparse][rest]") { // Create data buffer to use std::stringstream repetitions; size_t repetition_num = 100; @@ -1538,12 +1511,9 @@ TEST_CASE( return start += 10; }); - Context ctx; - VFS vfs(ctx); - - // Create the array - if (vfs.is_dir(array_name)) - vfs.remove_dir(array_name); + test::VFSTestSetup vfs_test_setup; + Context ctx{vfs_test_setup.ctx()}; + auto array_name{vfs_test_setup.array_uri("test_rle_string_dim")}; Domain domain(ctx); auto dim = @@ -1567,87 +1537,36 @@ TEST_CASE( SECTION("Unordered write") { write_sparse_array_string_dim( - ctx, - array_name, - data, - data_elem_offsets, - TILEDB_UNORDERED, - serialized, - refactored_query_v2); + ctx, array_name, data, data_elem_offsets, TILEDB_UNORDERED); SECTION("Row major read") { read_and_check_sparse_array_string_dim( - ctx, - array_name, - data, - data_elem_offsets, - TILEDB_ROW_MAJOR, - serialized, - refactored_query_v2); + ctx, array_name, data, data_elem_offsets, TILEDB_ROW_MAJOR); } SECTION("Global order read") { read_and_check_sparse_array_string_dim( - ctx, - array_name, - data, - data_elem_offsets, - TILEDB_GLOBAL_ORDER, - serialized, - refactored_query_v2); + ctx, array_name, data, data_elem_offsets, TILEDB_GLOBAL_ORDER); } SECTION("Unordered read") { read_and_check_sparse_array_string_dim( - ctx, - array_name, - data, - data_elem_offsets, - TILEDB_UNORDERED, - serialized, - refactored_query_v2); + ctx, array_name, data, data_elem_offsets, TILEDB_UNORDERED); } } SECTION("Global order write") { write_sparse_array_string_dim( - ctx, - array_name, - data, - data_elem_offsets, - TILEDB_GLOBAL_ORDER, - serialized, - refactored_query_v2); + ctx, array_name, data, data_elem_offsets, TILEDB_GLOBAL_ORDER); SECTION("Row major read") { read_and_check_sparse_array_string_dim( - ctx, - array_name, - data, - data_elem_offsets, - TILEDB_ROW_MAJOR, - serialized, - refactored_query_v2); + ctx, array_name, data, data_elem_offsets, TILEDB_ROW_MAJOR); } SECTION("Global order read") { read_and_check_sparse_array_string_dim( - ctx, - array_name, - data, - data_elem_offsets, - TILEDB_GLOBAL_ORDER, - serialized, - refactored_query_v2); + ctx, array_name, data, data_elem_offsets, TILEDB_GLOBAL_ORDER); } SECTION("Unordered read") { read_and_check_sparse_array_string_dim( - ctx, - array_name, - data, - data_elem_offsets, - TILEDB_UNORDERED, - serialized, - refactored_query_v2); + ctx, array_name, data, data_elem_offsets, TILEDB_UNORDERED); } } - - if (vfs.is_dir(array_name)) - vfs.remove_dir(array_name); } TEST_CASE( diff --git a/test/src/unit-query-plan.cc b/test/src/unit-query-plan.cc index f3fe5ec7fe0..8df96f60fda 100644 --- a/test/src/unit-query-plan.cc +++ b/test/src/unit-query-plan.cc @@ -37,32 +37,25 @@ #include "tiledb/sm/cpp_api/tiledb" #include "tiledb/sm/cpp_api/tiledb_experimental" -using namespace tiledb; - -#ifndef TILEDB_TESTS_ENABLE_REST -constexpr bool rest_tests = false; -#else -constexpr bool rest_tests = true; -#endif +using namespace tiledb::test; struct QueryPlanFx { QueryPlanFx(); - ~QueryPlanFx(); void create_dense_array(const std::string& array_name); void create_sparse_array(const std::string& array_name); - // Vector of supported filsystems - tiledb_ctx_handle_t* ctx_c_{nullptr}; - tiledb_vfs_handle_t* vfs_c_{nullptr}; - const std::vector> fs_vec_; + VFSTestSetup vfs_test_setup_; - std::string temp_dir_; - std::string abs_uri_; + // TileDB context + tiledb_ctx_t* ctx_c_; std::string uri_; - Context ctx_; }; +QueryPlanFx::QueryPlanFx() + : ctx_c_(vfs_test_setup_.ctx_c) { +} + TEST_CASE_METHOD( QueryPlanFx, "C API: tiledb_query_get_plan API lifecycle checks", @@ -253,31 +246,8 @@ TEST_CASE_METHOD( tiledb_array_free(&array); } -QueryPlanFx::QueryPlanFx() - : fs_vec_(test::vfs_test_get_fs_vec()) { - auto rc = test::vfs_test_init(fs_vec_, &ctx_c_, &vfs_c_); - if (!rc.ok()) { - throw std::runtime_error("Error initializing vfs in test set up."); - } - - ctx_ = Context(ctx_c_); - temp_dir_ = fs_vec_[0]->temp_dir(); - test::vfs_test_create_temp_dir(ctx_c_, vfs_c_, temp_dir_); -} - -QueryPlanFx::~QueryPlanFx() { - test::vfs_test_remove_temp_dir(ctx_c_, vfs_c_, temp_dir_); - test::vfs_test_close(fs_vec_, ctx_c_, vfs_c_).ok(); - tiledb_vfs_free(&vfs_c_); -} - void QueryPlanFx::create_dense_array(const std::string& array_name) { - if constexpr (rest_tests) { - uri_ = "tiledb://unit/"; - } - - abs_uri_ = temp_dir_ + "/" + array_name; - uri_ += abs_uri_; + uri_ = vfs_test_setup_.array_uri(array_name); // Create array schema tiledb_array_schema_t* array_schema; @@ -347,12 +317,7 @@ void QueryPlanFx::create_dense_array(const std::string& array_name) { } void QueryPlanFx::create_sparse_array(const std::string& array_name) { - if constexpr (rest_tests) { - uri_ = "tiledb://unit/"; - } - - abs_uri_ = temp_dir_ + "/" + array_name; - uri_ += abs_uri_; + uri_ = vfs_test_setup_.array_uri(array_name); // Create dimensions uint64_t tile_extents[] = {2, 2}; diff --git a/test/src/unit-sparse-global-order-reader.cc b/test/src/unit-sparse-global-order-reader.cc index 77580430b1e..d2ddfcbd652 100644 --- a/test/src/unit-sparse-global-order-reader.cc +++ b/test/src/unit-sparse-global-order-reader.cc @@ -31,6 +31,7 @@ */ #include "test/support/src/helpers.h" +#include "test/support/src/vfs_helpers.h" #include "tiledb/sm/c_api/tiledb.h" #include "tiledb/sm/c_api/tiledb_struct_def.h" #include "tiledb/sm/cpp_api/tiledb" @@ -1122,22 +1123,10 @@ TEST_CASE_METHOD( TEST_CASE( "Sparse global order reader: user buffer cannot fit single cell", - "[sparse-global-order][user-buffer][too-small]") { - bool serialized = false, refactored_query_v2 = false; -#ifdef TILEDB_SERIALIZATION - serialized = GENERATE(true, false); - if (serialized) { - refactored_query_v2 = GENERATE(true, false); - } -#endif - - std::string array_name = "test_sparse_global_order"; - Context ctx; - VFS vfs(ctx); - - if (vfs.is_dir(array_name)) { - vfs.remove_dir(array_name); - } + "[sparse-global-order][user-buffer][too-small][rest]") { + VFSTestSetup vfs_test_setup; + std::string array_name = vfs_test_setup.array_uri("test_sparse_global_order"); + auto ctx = vfs_test_setup.ctx(); // Create array with var-sized attribute. Domain dom(ctx); @@ -1171,15 +1160,7 @@ TEST_CASE( query.set_offsets_buffer("a", a1_offsets); // Submit query - ServerQueryBuffers server_buffers_; - auto rc = submit_query_wrapper( - ctx, - array_name, - &query, - server_buffers_, - serialized, - refactored_query_v2); - REQUIRE(rc == TILEDB_OK); + query.submit_and_finalize(); // Read using a buffer that can't fit a single result Array array2(ctx, array_name, TILEDB_READ); @@ -1198,48 +1179,26 @@ TEST_CASE( // The user buffer cannot fit a single result so it should return Incomplete // with the right reason - rc = submit_query_wrapper( - ctx, - array_name, - &query2, - server_buffers_, - serialized, - refactored_query_v2, - false); - REQUIRE(rc == TILEDB_OK); + query2.submit(); REQUIRE(query2.query_status() == Query::Status::INCOMPLETE); - // For remote arrays the reason is always TILEDB_REASON_USER_BUFFER_SIZE, - // but we can't test it here since we simulate "remote" arrays by using a - // local URI so the array->is_remote() check will fail, and we won't get the - // correct result. - if (!serialized) { - tiledb_query_status_details_t details; - rc = tiledb_query_get_status_details( - ctx.ptr().get(), query2.ptr().get(), &details); - CHECK(rc == TILEDB_OK); - CHECK(details.incomplete_reason == TILEDB_REASON_USER_BUFFER_SIZE); - } + tiledb_query_status_details_t details; + auto rc = tiledb_query_get_status_details( + ctx.ptr().get(), query2.ptr().get(), &details); + CHECK(rc == TILEDB_OK); + CHECK(details.incomplete_reason == TILEDB_REASON_USER_BUFFER_SIZE); array2.close(); - - if (vfs.is_dir(array_name)) { - vfs.remove_dir(array_name); - } } TEST_CASE( "Sparse global order reader: attribute copy memory limit", - "[sparse-global-order][attribute-copy][memory-limit]") { - std::string array_name = "test_sparse_global_order"; + "[sparse-global-order][attribute-copy][memory-limit][rest]") { Config config; config["sm.mem.total_budget"] = "10000"; - Context ctx(config); - VFS vfs(ctx); - - if (vfs.is_dir(array_name)) { - vfs.remove_dir(array_name); - } + VFSTestSetup vfs_test_setup(config.ptr().get()); + std::string array_name = vfs_test_setup.array_uri("test_sparse_global_order"); + auto ctx = vfs_test_setup.ctx(); // Create array with var-sized attribute. Domain dom(ctx); @@ -1274,8 +1233,7 @@ TEST_CASE( query.set_data_buffer("d1", d1); query.set_data_buffer("a", a1_data); query.set_offsets_buffer("a", a1_offsets); - CHECK_NOTHROW(query.submit()); - CHECK_NOTHROW(query.finalize()); + CHECK_NOTHROW(query.submit_and_finalize()); // Read using a budget that can only fit one of the var size tiles. Array array2(ctx, array_name, TILEDB_READ); @@ -1304,10 +1262,6 @@ TEST_CASE( CHECK(result_num == 4); array2.close(); - - if (vfs.is_dir(array_name)) { - vfs.remove_dir(array_name); - } } TEST_CASE_METHOD( diff --git a/test/support/src/vfs_helpers.cc b/test/support/src/vfs_helpers.cc index ed48e83a1df..802a0342a4d 100644 --- a/test/support/src/vfs_helpers.cc +++ b/test/support/src/vfs_helpers.cc @@ -149,6 +149,15 @@ void vfs_test_create_temp_dir( CHECK(tiledb_vfs_create_dir(ctx, vfs, path.c_str()) == TILEDB_OK); } +std::string vfs_array_uri( + const std::unique_ptr& fs, const std::string& array_name) { + if (fs->is_rest()) { + return ("tiledb://unit/" + array_name); + } else { + return array_name; + } +} + Status SupportedFsS3::prepare_config( [[maybe_unused]] tiledb_config_t* config, [[maybe_unused]] tiledb_error_t* error) { diff --git a/test/support/src/vfs_helpers.h b/test/support/src/vfs_helpers.h index aeb3c704292..16e0c18cdee 100644 --- a/test/support/src/vfs_helpers.h +++ b/test/support/src/vfs_helpers.h @@ -95,6 +95,10 @@ void vfs_test_remove_temp_dir( void vfs_test_create_temp_dir( tiledb_ctx_t* ctx, tiledb_vfs_t* vfs, const std::string& path); + +std::string vfs_array_uri( + const std::unique_ptr& fs, const std::string& array_name); + /** * This class defines and manipulates * a list of supported filesystems. @@ -884,22 +888,36 @@ struct TemporaryDirectoryFixture { * { * tiledb::test::VFSTestSetup vfs_test_setup{"foo_array"}; * auto ctx = vfs_test_setup.ctx(); + * auto array_uri = vfs_test_setup.array_uri("quickstart_sparse"); * Array array(ctx, array_uri, TILEDB_WRITE); * ... * } // ctx context is destroyed and VFS directories removed * */ struct VFSTestSetup { - VFSTestSetup(tiledb_config_t* config = nullptr) + VFSTestSetup(tiledb_config_t* config = nullptr, bool remove_tmpdir = true) : fs_vec(vfs_test_get_fs_vec()) , ctx_c{nullptr} , vfs_c{nullptr} , cfg_c{config} { vfs_test_init(fs_vec, &ctx_c, &vfs_c, cfg_c).ok(); temp_dir = fs_vec[0]->temp_dir(); - vfs_test_create_temp_dir(ctx_c, vfs_c, temp_dir); + if (remove_tmpdir) { + vfs_test_remove_temp_dir(ctx_c, vfs_c, temp_dir); + } + tiledb_vfs_create_dir(ctx_c, vfs_c, temp_dir.c_str()); }; + void update_config(tiledb_config_t* config) { + // free resources + tiledb_ctx_free(&ctx_c); + tiledb_vfs_free(&vfs_c); + cfg_c = config; + + // reallocate with input config + vfs_test_init(fs_vec, &ctx_c, &vfs_c, cfg_c).ok(); + } + bool is_rest() { return fs_vec[0]->is_rest(); } @@ -908,10 +926,12 @@ struct VFSTestSetup { return fs_vec[0]->is_local(); } - std::string array_uri(const std::string& array_name) { - return ( - fs_vec[0]->is_rest() ? "tiledb://unit/" + temp_dir + array_name : - temp_dir + array_name); + std::string array_uri( + const std::string& array_name, bool strip_tiledb_prefix = false) { + auto uri = (fs_vec[0]->is_rest() && !strip_tiledb_prefix) ? + ("tiledb://unit/" + temp_dir + array_name) : + (temp_dir + array_name); + return uri; } Context ctx() { @@ -920,7 +940,7 @@ struct VFSTestSetup { ~VFSTestSetup() { vfs_test_remove_temp_dir(ctx_c, vfs_c, temp_dir); - CHECK(vfs_test_close(fs_vec, ctx_c, vfs_c).ok()); + vfs_test_close(fs_vec, ctx_c, vfs_c).ok(); tiledb_ctx_free(&ctx_c); tiledb_vfs_free(&vfs_c);