/** * @file multi_attribute.c * * @section LICENSE * * The MIT License * * @copyright Copyright (c) 2018-2020 TileDB, Inc. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. * * @section DESCRIPTION * * When run, this program will create a simple 2D dense array with two * attributes, write some data to it, and read a slice of the data back on * (i) both attributes, and (ii) subselecting on only one of the attributes. */ #include #include // Name of array. const char* array_name = "multi_attribute_array"; void create_array() { // Create TileDB context tiledb_ctx_t* ctx; tiledb_ctx_alloc(NULL, &ctx); // The array will be 4x4 with dimensions "rows" and "cols", with domain [1,4]. int dim_domain[] = {1, 4, 1, 4}; int tile_extents[] = {4, 4}; tiledb_dimension_t* d1; tiledb_dimension_alloc( ctx, "rows", TILEDB_INT32, &dim_domain[0], &tile_extents[0], &d1); tiledb_dimension_t* d2; tiledb_dimension_alloc( ctx, "cols", TILEDB_INT32, &dim_domain[2], &tile_extents[1], &d2); // Create domain tiledb_domain_t* domain; tiledb_domain_alloc(ctx, &domain); tiledb_domain_add_dimension(ctx, domain, d1); tiledb_domain_add_dimension(ctx, domain, d2); // Create two attributes "a1" and "a2", so each (i,j) cell can store // a character on "a1" and a vector of two floats on "a2". tiledb_attribute_t* a1; tiledb_attribute_alloc(ctx, "a1", TILEDB_CHAR, &a1); tiledb_attribute_t* a2; tiledb_attribute_alloc(ctx, "a2", TILEDB_FLOAT32, &a2); tiledb_attribute_set_cell_val_num(ctx, a2, 2); // Create array schema tiledb_array_schema_t* array_schema; tiledb_array_schema_alloc(ctx, TILEDB_DENSE, &array_schema); tiledb_array_schema_set_cell_order(ctx, array_schema, TILEDB_ROW_MAJOR); tiledb_array_schema_set_tile_order(ctx, array_schema, TILEDB_ROW_MAJOR); tiledb_array_schema_set_domain(ctx, array_schema, domain); tiledb_array_schema_add_attribute(ctx, array_schema, a1); tiledb_array_schema_add_attribute(ctx, array_schema, a2); // Create array tiledb_array_create(ctx, array_name, array_schema); // Clean up tiledb_attribute_free(&a1); tiledb_attribute_free(&a2); tiledb_dimension_free(&d1); tiledb_dimension_free(&d2); tiledb_domain_free(&domain); tiledb_array_schema_free(&array_schema); tiledb_ctx_free(&ctx); } void write_array() { // Create TileDB context tiledb_ctx_t* ctx; tiledb_ctx_alloc(NULL, &ctx); // Open array for writing tiledb_array_t* array; tiledb_array_alloc(ctx, array_name, &array); tiledb_array_open(ctx, array, TILEDB_WRITE); // Prepare some data for the array char a1[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p'}; uint64_t a1_size = sizeof(a1); float a2[] = {1.1f, 1.2f, 2.1f, 2.2f, 3.1f, 3.2f, 4.1f, 4.2f, 5.1f, 5.2f, 6.1f, 6.2f, 7.1f, 7.2f, 8.1f, 8.2f, 9.1f, 9.2f, 10.1f, 10.2f, 11.1f, 11.2f, 12.1f, 12.2f, 13.1f, 13.2f, 14.1f, 14.2f, 15.1f, 15.2f, 16.1f, 16.2f}; uint64_t a2_size = sizeof(a2); // Create the query tiledb_query_t* query; tiledb_query_alloc(ctx, array, TILEDB_WRITE, &query); tiledb_query_set_layout(ctx, query, TILEDB_ROW_MAJOR); tiledb_query_set_buffer(ctx, query, "a1", a1, &a1_size); tiledb_query_set_buffer(ctx, query, "a2", a2, &a2_size); // Submit query tiledb_query_submit(ctx, query); // Close array tiledb_array_close(ctx, array); // Clean up tiledb_array_free(&array); tiledb_query_free(&query); tiledb_ctx_free(&ctx); } void read_array() { // Create TileDB context tiledb_ctx_t* ctx; tiledb_ctx_alloc(NULL, &ctx); // Open array for reading tiledb_array_t* array; tiledb_array_alloc(ctx, array_name, &array); tiledb_array_open(ctx, array, TILEDB_READ); // Slice only rows 1, 2 and cols 2, 3, 4 int subarray[] = {1, 2, 2, 4}; // Prepare the vectors that will hold the results char a1[6]; uint64_t a1_size = sizeof(a1); float a2[12]; uint64_t a2_size = sizeof(a2); // Create query tiledb_query_t* query; tiledb_query_alloc(ctx, array, TILEDB_READ, &query); tiledb_query_set_subarray(ctx, query, subarray); tiledb_query_set_layout(ctx, query, TILEDB_ROW_MAJOR); tiledb_query_set_buffer(ctx, query, "a1", a1, &a1_size); tiledb_query_set_buffer(ctx, query, "a2", a2, &a2_size); // Submit query tiledb_query_submit(ctx, query); // Close array tiledb_array_close(ctx, array); // Print out the results. printf("Reading both attributes a1 and a2:\n"); for (int i = 0; i < 6; ++i) printf("a1: %c, a2: (%.1f, %.1f)\n", a1[i], a2[2 * i], a2[2 * i + 1]); printf("\n"); // Clean up tiledb_array_free(&array); tiledb_query_free(&query); tiledb_ctx_free(&ctx); } void read_array_subselect() { // Create TileDB context tiledb_ctx_t* ctx; tiledb_ctx_alloc(NULL, &ctx); // Open array for reading tiledb_array_t* array; tiledb_array_alloc(ctx, array_name, &array); tiledb_array_open(ctx, array, TILEDB_READ); // Slice only rows 1, 2 and cols 2, 3, 4 int subarray[] = {1, 2, 2, 4}; // Prepare the vector that will hold the results char a1[6]; uint64_t a1_size = sizeof(a1); // Create query tiledb_query_t* query; tiledb_query_alloc(ctx, array, TILEDB_READ, &query); tiledb_query_set_subarray(ctx, query, subarray); tiledb_query_set_layout(ctx, query, TILEDB_ROW_MAJOR); tiledb_query_set_buffer(ctx, query, "a1", a1, &a1_size); // Submit query tiledb_query_submit(ctx, query); // Close array tiledb_array_close(ctx, array); // Print out the results. printf("Reading both attributes a1 and a2:\n"); for (int i = 0; i < 6; ++i) printf("a1: %c\n", a1[i]); // Clean up tiledb_array_free(&array); tiledb_query_free(&query); tiledb_ctx_free(&ctx); } int main() { // Get object type tiledb_ctx_t* ctx; tiledb_ctx_alloc(NULL, &ctx); tiledb_object_t type; tiledb_object_type(ctx, array_name, &type); tiledb_ctx_free(&ctx); if (type != TILEDB_ARRAY) { create_array(); write_array(); } read_array(); read_array_subselect(); return 0; }