From db4eeabe2fb152cf4449edf060e700ce82195757 Mon Sep 17 00:00:00 2001 From: gsvic Date: Tue, 28 Apr 2020 18:53:46 +0300 Subject: [PATCH 1/2] update to tiledb 2.0.0 --- gradle.properties | 2 +- src/main/c/generated/tiledb_wrap.cxx | 464 +++++++++++++++++- src/main/java/io/tiledb/java/api/Query.java | 32 +- src/main/java/io/tiledb/libtiledb/tiledb.java | 238 ++++++++- .../io/tiledb/libtiledb/tiledbConstants.java | 6 +- .../java/io/tiledb/libtiledb/tiledbJNI.java | 53 ++ .../tiledb/libtiledb/tiledb_filesystem_t.java | 4 +- .../libtiledb/tiledb_filter_type_t.java | 4 +- .../java/io/tiledb/java/api/VersionTest.java | 5 +- 9 files changed, 768 insertions(+), 40 deletions(-) diff --git a/gradle.properties b/gradle.properties index ef7f7df6..44eb70dc 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,5 +1,5 @@ TILEDB_GIT_REPOSITORY=https://github.com/TileDB-Inc/TileDB -TILEDB_GIT_TAG=1.7.7 +TILEDB_GIT_TAG=2.0.0-rc5 TILEDB_VERBOSE=OFF TILEDB_S3=OFF TILEDB_HDFS=OFF diff --git a/src/main/c/generated/tiledb_wrap.cxx b/src/main/c/generated/tiledb_wrap.cxx index 90ce6cb6..b8a6fd5a 100644 --- a/src/main/c/generated/tiledb_wrap.cxx +++ b/src/main/c/generated/tiledb_wrap.cxx @@ -6275,6 +6275,78 @@ SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1dimension_1fr } +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1dimension_1set_1filter_1list(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_dimension_t *arg2 = (tiledb_dimension_t *) 0 ; + tiledb_filter_list_t *arg3 = (tiledb_filter_list_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_dimension_t **)&jarg2; + arg3 = *(tiledb_filter_list_t **)&jarg3; + result = (int32_t)tiledb_dimension_set_filter_list(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1dimension_1set_1cell_1val_1num(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_dimension_t *arg2 = (tiledb_dimension_t *) 0 ; + uint32_t arg3 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_dimension_t **)&jarg2; + arg3 = (uint32_t)jarg3; + result = (int32_t)tiledb_dimension_set_cell_val_num(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1dimension_1get_1filter_1list(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_dimension_t *arg2 = (tiledb_dimension_t *) 0 ; + tiledb_filter_list_t **arg3 = (tiledb_filter_list_t **) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_dimension_t **)&jarg2; + arg3 = *(tiledb_filter_list_t ***)&jarg3; + result = (int32_t)tiledb_dimension_get_filter_list(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1dimension_1get_1cell_1val_1num(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_dimension_t *arg2 = (tiledb_dimension_t *) 0 ; + uint32_t *arg3 = (uint32_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_dimension_t **)&jarg2; + arg3 = *(uint32_t **)&jarg3; + result = (int32_t)tiledb_dimension_get_cell_val_num(arg1,(tiledb_dimension_t const *)arg2,arg3); + jresult = (jint)result; + return jresult; +} + + SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1dimension_1get_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { jint jresult = 0 ; tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; @@ -6323,7 +6395,7 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1dimension_1ge arg1 = *(tiledb_ctx_t **)&jarg1; arg2 = *(tiledb_dimension_t **)&jarg2; arg3 = *(void ***)&jarg3; - result = (int32_t)tiledb_dimension_get_domain(arg1,(tiledb_dimension_t const *)arg2,arg3); + result = (int32_t)tiledb_dimension_get_domain(arg1,(tiledb_dimension_t const *)arg2,(void const **)arg3); jresult = (jint)result; return jresult; } @@ -6341,7 +6413,7 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1dimension_1ge arg1 = *(tiledb_ctx_t **)&jarg1; arg2 = *(tiledb_dimension_t **)&jarg2; arg3 = *(void ***)&jarg3; - result = (int32_t)tiledb_dimension_get_tile_extent(arg1,(tiledb_dimension_t const *)arg2,arg3); + result = (int32_t)tiledb_dimension_get_tile_extent(arg1,(tiledb_dimension_t const *)arg2,(void const **)arg3); jresult = (jint)result; return jresult; } @@ -6411,6 +6483,42 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1schema } +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1schema_1set_1allows_1dups(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jint jarg3) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_array_schema_t *arg2 = (tiledb_array_schema_t *) 0 ; + int arg3 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_schema_t **)&jarg2; + arg3 = (int)jarg3; + result = (int32_t)tiledb_array_schema_set_allows_dups(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1schema_1get_1allows_1dups(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_array_schema_t *arg2 = (tiledb_array_schema_t *) 0 ; + int *arg3 = (int *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_schema_t **)&jarg2; + arg3 = *(int **)&jarg3; + result = (int32_t)tiledb_array_schema_get_allows_dups(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1schema_1set_1domain(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { jint jresult = 0 ; tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; @@ -7174,6 +7282,82 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1add_1r } +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1add_1range_1var(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg5, jlong jarg6, jobject jarg7) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_query_t *arg2 = (tiledb_query_t *) 0 ; + uint32_t arg3 ; + void *arg4 = (void *) 0 ; + uint64_t arg5 ; + void *arg6 = (void *) 0 ; + uint64_t arg7 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_query_t **)&jarg2; + arg3 = (uint32_t)jarg3; + arg4 = *(void **)&jarg4; + { + jclass clazz; + jmethodID mid; + jbyteArray ba; + jbyte* bae; + jsize sz; + int i; + + if (!jarg5) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null"); + return 0; + } + clazz = jenv->GetObjectClass(jarg5); + mid = jenv->GetMethodID(clazz, "toByteArray", "()[B"); + ba = (jbyteArray)jenv->CallObjectMethod(jarg5, mid); + bae = jenv->GetByteArrayElements(ba, 0); + sz = jenv->GetArrayLength(ba); + arg5 = 0; + if (sz > 0) { + arg5 = (uint64_t)(signed char)bae[0]; + for(i=1; iReleaseByteArrayElements(ba, bae, 0); + } + arg6 = *(void **)&jarg6; + { + jclass clazz; + jmethodID mid; + jbyteArray ba; + jbyte* bae; + jsize sz; + int i; + + if (!jarg7) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null"); + return 0; + } + clazz = jenv->GetObjectClass(jarg7); + mid = jenv->GetMethodID(clazz, "toByteArray", "()[B"); + ba = (jbyteArray)jenv->CallObjectMethod(jarg7, mid); + bae = jenv->GetByteArrayElements(ba, 0); + sz = jenv->GetArrayLength(ba); + arg7 = 0; + if (sz > 0) { + arg7 = (uint64_t)(signed char)bae[0]; + for(i=1; iReleaseByteArrayElements(ba, bae, 0); + } + result = (int32_t)tiledb_query_add_range_var(arg1,arg2,arg3,(void const *)arg4,arg5,(void const *)arg6,arg7); + jresult = (jint)result; + return jresult; +} + + SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1get_1range_1num(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { jint jresult = 0 ; tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; @@ -7245,6 +7429,104 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1get_1r } +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1get_1range_1var_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jobject jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_query_t *arg2 = (tiledb_query_t *) 0 ; + uint32_t arg3 ; + uint64_t arg4 ; + uint64_t *arg5 = (uint64_t *) 0 ; + uint64_t *arg6 = (uint64_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_query_t **)&jarg2; + arg3 = (uint32_t)jarg3; + { + jclass clazz; + jmethodID mid; + jbyteArray ba; + jbyte* bae; + jsize sz; + int i; + + if (!jarg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null"); + return 0; + } + clazz = jenv->GetObjectClass(jarg4); + mid = jenv->GetMethodID(clazz, "toByteArray", "()[B"); + ba = (jbyteArray)jenv->CallObjectMethod(jarg4, mid); + bae = jenv->GetByteArrayElements(ba, 0); + sz = jenv->GetArrayLength(ba); + arg4 = 0; + if (sz > 0) { + arg4 = (uint64_t)(signed char)bae[0]; + for(i=1; iReleaseByteArrayElements(ba, bae, 0); + } + arg5 = *(uint64_t **)&jarg5; + arg6 = *(uint64_t **)&jarg6; + result = (int32_t)tiledb_query_get_range_var_size(arg1,(tiledb_query_t const *)arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1get_1range_1var(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jobject jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_query_t *arg2 = (tiledb_query_t *) 0 ; + uint32_t arg3 ; + uint64_t arg4 ; + void *arg5 = (void *) 0 ; + void *arg6 = (void *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_query_t **)&jarg2; + arg3 = (uint32_t)jarg3; + { + jclass clazz; + jmethodID mid; + jbyteArray ba; + jbyte* bae; + jsize sz; + int i; + + if (!jarg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null"); + return 0; + } + clazz = jenv->GetObjectClass(jarg4); + mid = jenv->GetMethodID(clazz, "toByteArray", "()[B"); + ba = (jbyteArray)jenv->CallObjectMethod(jarg4, mid); + bae = jenv->GetByteArrayElements(ba, 0); + sz = jenv->GetArrayLength(ba); + arg4 = 0; + if (sz > 0) { + arg4 = (uint64_t)(signed char)bae[0]; + for(i=1; iReleaseByteArrayElements(ba, bae, 0); + } + arg5 = *(void **)&jarg5; + arg6 = *(void **)&jarg6; + result = (int32_t)tiledb_query_get_range_var(arg1,(tiledb_query_t const *)arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; + return jresult; +} + + SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1get_1est_1result_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4) { jint jresult = 0 ; tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; @@ -7829,6 +8111,29 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1consol } +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1vacuum(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + char *arg2 = (char *) 0 ; + tiledb_config_t *arg3 = (tiledb_config_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = *(tiledb_config_t **)&jarg3; + result = (int32_t)tiledb_array_vacuum(arg1,(char const *)arg2,arg3); + jresult = (jint)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1get_1non_1empty_1domain(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { jint jresult = 0 ; tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; @@ -7849,6 +8154,161 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1get_1n } +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1get_1non_1empty_1domain_1from_1index(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_array_t *arg2 = (tiledb_array_t *) 0 ; + uint32_t arg3 ; + void *arg4 = (void *) 0 ; + int32_t *arg5 = (int32_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_t **)&jarg2; + arg3 = (uint32_t)jarg3; + arg4 = *(void **)&jarg4; + arg5 = *(int32_t **)&jarg5; + result = (int32_t)tiledb_array_get_non_empty_domain_from_index(arg1,arg2,arg3,arg4,arg5); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1get_1non_1empty_1domain_1from_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_array_t *arg2 = (tiledb_array_t *) 0 ; + char *arg3 = (char *) 0 ; + void *arg4 = (void *) 0 ; + int32_t *arg5 = (int32_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_t **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(void **)&jarg4; + arg5 = *(int32_t **)&jarg5; + result = (int32_t)tiledb_array_get_non_empty_domain_from_name(arg1,arg2,(char const *)arg3,arg4,arg5); + jresult = (jint)result; + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1get_1non_1empty_1domain_1var_1size_1from_1index(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_array_t *arg2 = (tiledb_array_t *) 0 ; + uint32_t arg3 ; + uint64_t *arg4 = (uint64_t *) 0 ; + uint64_t *arg5 = (uint64_t *) 0 ; + int32_t *arg6 = (int32_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_t **)&jarg2; + arg3 = (uint32_t)jarg3; + arg4 = *(uint64_t **)&jarg4; + arg5 = *(uint64_t **)&jarg5; + arg6 = *(int32_t **)&jarg6; + result = (int32_t)tiledb_array_get_non_empty_domain_var_size_from_index(arg1,arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1get_1non_1empty_1domain_1var_1size_1from_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_array_t *arg2 = (tiledb_array_t *) 0 ; + char *arg3 = (char *) 0 ; + uint64_t *arg4 = (uint64_t *) 0 ; + uint64_t *arg5 = (uint64_t *) 0 ; + int32_t *arg6 = (int32_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_t **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(uint64_t **)&jarg4; + arg5 = *(uint64_t **)&jarg5; + arg6 = *(int32_t **)&jarg6; + result = (int32_t)tiledb_array_get_non_empty_domain_var_size_from_name(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + jresult = (jint)result; + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1get_1non_1empty_1domain_1var_1from_1index(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_array_t *arg2 = (tiledb_array_t *) 0 ; + uint32_t arg3 ; + void *arg4 = (void *) 0 ; + void *arg5 = (void *) 0 ; + int32_t *arg6 = (int32_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_t **)&jarg2; + arg3 = (uint32_t)jarg3; + arg4 = *(void **)&jarg4; + arg5 = *(void **)&jarg5; + arg6 = *(int32_t **)&jarg6; + result = (int32_t)tiledb_array_get_non_empty_domain_var_from_index(arg1,arg2,arg3,arg4,arg5,arg6); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1get_1non_1empty_1domain_1var_1from_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_array_t *arg2 = (tiledb_array_t *) 0 ; + char *arg3 = (char *) 0 ; + void *arg4 = (void *) 0 ; + void *arg5 = (void *) 0 ; + int32_t *arg6 = (int32_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_t **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(void **)&jarg4; + arg5 = *(void **)&jarg5; + arg6 = *(int32_t **)&jarg6; + result = (int32_t)tiledb_array_get_non_empty_domain_var_from_name(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + jresult = (jint)result; + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1max_1buffer_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5) { jint jresult = 0 ; tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; diff --git a/src/main/java/io/tiledb/java/api/Query.java b/src/main/java/io/tiledb/java/api/Query.java index c6ab8b50..b2baad23 100644 --- a/src/main/java/io/tiledb/java/api/Query.java +++ b/src/main/java/io/tiledb/java/api/Query.java @@ -260,21 +260,23 @@ public Pair getRange(int dimIdx, long rangeIdx) throws TileDBErr } /** - * Sets a buffer for a fixed-sized attribute. + * Sets a buffer for a fixed-sized attribute or dimension. * - * @param attr The attribute name. + * @param attr The attribute/dimension name. * @param buffer NativeBuffer to be used for the attribute values. * @exception TileDBError A TileDB exception */ public synchronized Query setBuffer(String attr, NativeArray buffer) throws TileDBError { try (ArraySchema schema = array.getSchema()) { - if (attr.equals(tiledb.tiledb_coords())) { - try (Domain domain = schema.getDomain()) { + try (Domain domain = schema.getDomain()) { + if (attr.equals(tiledb.tiledb_coords())) { Types.typeCheck(domain.getType(), buffer.getNativeType()); - } - } else { - try (Attribute attribute = schema.getAttribute(attr)) { - Types.typeCheck(attribute.getType(), buffer.getNativeType()); + } else if (domain.hasDimension(attr)) { + Types.typeCheck(domain.getType(), buffer.getNativeType()); + } else { + try (Attribute attribute = schema.getAttribute(attr)) { + Types.typeCheck(attribute.getType(), buffer.getNativeType()); + } } } } @@ -327,13 +329,15 @@ public synchronized Query setBuffer(String attr, NativeArray buffer, long buffer } try (ArraySchema schema = array.getSchema()) { - if (attr.equals(tiledb.tiledb_coords())) { - try (Domain domain = schema.getDomain()) { + try (Domain domain = schema.getDomain()) { + if (attr.equals(tiledb.tiledb_coords())) { Types.typeCheck(domain.getType(), buffer.getNativeType()); - } - } else { - try (Attribute attribute = schema.getAttribute(attr)) { - Types.typeCheck(attribute.getType(), buffer.getNativeType()); + } else if (domain.hasDimension(attr)) { + Types.typeCheck(domain.getType(), buffer.getNativeType()); + } else { + try (Attribute attribute = schema.getAttribute(attr)) { + Types.typeCheck(attribute.getType(), buffer.getNativeType()); + } } } } diff --git a/src/main/java/io/tiledb/libtiledb/tiledb.java b/src/main/java/io/tiledb/libtiledb/tiledb.java index 27f4cdfc..37d21b93 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledb.java +++ b/src/main/java/io/tiledb/libtiledb/tiledb.java @@ -1754,6 +1754,44 @@ public static void tiledb_dimension_free(SWIGTYPE_p_p_tiledb_dimension_t dim) { tiledbJNI.tiledb_dimension_free(SWIGTYPE_p_p_tiledb_dimension_t.getCPtr(dim)); } + public static int tiledb_dimension_set_filter_list( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_dimension_t dim, + SWIGTYPE_p_tiledb_filter_list_t filter_list) { + return tiledbJNI.tiledb_dimension_set_filter_list( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_dimension_t.getCPtr(dim), + SWIGTYPE_p_tiledb_filter_list_t.getCPtr(filter_list)); + } + + public static int tiledb_dimension_set_cell_val_num( + SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_dimension_t dim, long cell_val_num) { + return tiledbJNI.tiledb_dimension_set_cell_val_num( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_dimension_t.getCPtr(dim), + cell_val_num); + } + + public static int tiledb_dimension_get_filter_list( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_dimension_t dim, + SWIGTYPE_p_p_tiledb_filter_list_t filter_list) { + return tiledbJNI.tiledb_dimension_get_filter_list( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_dimension_t.getCPtr(dim), + SWIGTYPE_p_p_tiledb_filter_list_t.getCPtr(filter_list)); + } + + public static int tiledb_dimension_get_cell_val_num( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_dimension_t dim, + SWIGTYPE_p_unsigned_int cell_val_num) { + return tiledbJNI.tiledb_dimension_get_cell_val_num( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_dimension_t.getCPtr(dim), + SWIGTYPE_p_unsigned_int.getCPtr(cell_val_num)); + } + public static int tiledb_dimension_get_name( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_dimension_t dim, SWIGTYPE_p_p_char name) { return tiledbJNI.tiledb_dimension_get_name( @@ -1822,6 +1860,24 @@ public static int tiledb_array_schema_add_attribute( SWIGTYPE_p_tiledb_attribute_t.getCPtr(attr)); } + public static int tiledb_array_schema_set_allows_dups( + SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_array_schema_t array_schema, int allows_dups) { + return tiledbJNI.tiledb_array_schema_set_allows_dups( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_schema_t.getCPtr(array_schema), + allows_dups); + } + + public static int tiledb_array_schema_get_allows_dups( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_schema_t array_schema, + SWIGTYPE_p_int allows_dups) { + return tiledbJNI.tiledb_array_schema_get_allows_dups( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_schema_t.getCPtr(array_schema), + SWIGTYPE_p_int.getCPtr(allows_dups)); + } + public static int tiledb_array_schema_set_domain( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_array_schema_t array_schema, @@ -2064,13 +2120,13 @@ public static int tiledb_query_set_subarray( public static int tiledb_query_set_buffer( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_query_t query, - String attribute, + String name, SWIGTYPE_p_void buffer, SWIGTYPE_p_unsigned_long_long buffer_size) { return tiledbJNI.tiledb_query_set_buffer( SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), SWIGTYPE_p_tiledb_query_t.getCPtr(query), - attribute, + name, SWIGTYPE_p_void.getCPtr(buffer), SWIGTYPE_p_unsigned_long_long.getCPtr(buffer_size)); } @@ -2078,7 +2134,7 @@ public static int tiledb_query_set_buffer( public static int tiledb_query_set_buffer_var( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_query_t query, - String attribute, + String name, SWIGTYPE_p_unsigned_long_long buffer_off, SWIGTYPE_p_unsigned_long_long buffer_off_size, SWIGTYPE_p_void buffer_val, @@ -2086,7 +2142,7 @@ public static int tiledb_query_set_buffer_var( return tiledbJNI.tiledb_query_set_buffer_var( SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), SWIGTYPE_p_tiledb_query_t.getCPtr(query), - attribute, + name, SWIGTYPE_p_unsigned_long_long.getCPtr(buffer_off), SWIGTYPE_p_unsigned_long_long.getCPtr(buffer_off_size), SWIGTYPE_p_void.getCPtr(buffer_val), @@ -2096,13 +2152,13 @@ public static int tiledb_query_set_buffer_var( public static int tiledb_query_get_buffer( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_query_t query, - String attribute, + String name, SWIGTYPE_p_p_void buffer, SWIGTYPE_p_p_unsigned_long_long buffer_size) { return tiledbJNI.tiledb_query_get_buffer( SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), SWIGTYPE_p_tiledb_query_t.getCPtr(query), - attribute, + name, SWIGTYPE_p_p_void.getCPtr(buffer), SWIGTYPE_p_p_unsigned_long_long.getCPtr(buffer_size)); } @@ -2110,7 +2166,7 @@ public static int tiledb_query_get_buffer( public static int tiledb_query_get_buffer_var( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_query_t query, - String attribute, + String name, SWIGTYPE_p_p_unsigned_long_long buffer_off, SWIGTYPE_p_p_unsigned_long_long buffer_off_size, SWIGTYPE_p_p_void buffer_val, @@ -2118,7 +2174,7 @@ public static int tiledb_query_get_buffer_var( return tiledbJNI.tiledb_query_get_buffer_var( SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), SWIGTYPE_p_tiledb_query_t.getCPtr(query), - attribute, + name, SWIGTYPE_p_p_unsigned_long_long.getCPtr(buffer_off), SWIGTYPE_p_p_unsigned_long_long.getCPtr(buffer_off_size), SWIGTYPE_p_p_void.getCPtr(buffer_val), @@ -2215,6 +2271,24 @@ public static int tiledb_query_add_range( SWIGTYPE_p_void.getCPtr(stride)); } + public static int tiledb_query_add_range_var( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_query_t query, + long dim_idx, + SWIGTYPE_p_void start, + java.math.BigInteger start_size, + SWIGTYPE_p_void end, + java.math.BigInteger end_size) { + return tiledbJNI.tiledb_query_add_range_var( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_query_t.getCPtr(query), + dim_idx, + SWIGTYPE_p_void.getCPtr(start), + start_size, + SWIGTYPE_p_void.getCPtr(end), + end_size); + } + public static int tiledb_query_get_range_num( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_query_t query, @@ -2245,28 +2319,60 @@ public static int tiledb_query_get_range( SWIGTYPE_p_p_void.getCPtr(stride)); } + public static int tiledb_query_get_range_var_size( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_query_t query, + long dim_idx, + java.math.BigInteger range_idx, + SWIGTYPE_p_unsigned_long_long start_size, + SWIGTYPE_p_unsigned_long_long end_size) { + return tiledbJNI.tiledb_query_get_range_var_size( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_query_t.getCPtr(query), + dim_idx, + range_idx, + SWIGTYPE_p_unsigned_long_long.getCPtr(start_size), + SWIGTYPE_p_unsigned_long_long.getCPtr(end_size)); + } + + public static int tiledb_query_get_range_var( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_query_t query, + long dim_idx, + java.math.BigInteger range_idx, + SWIGTYPE_p_void start, + SWIGTYPE_p_void end) { + return tiledbJNI.tiledb_query_get_range_var( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_query_t.getCPtr(query), + dim_idx, + range_idx, + SWIGTYPE_p_void.getCPtr(start), + SWIGTYPE_p_void.getCPtr(end)); + } + public static int tiledb_query_get_est_result_size( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_query_t query, - String attr_name, + String name, SWIGTYPE_p_unsigned_long_long size) { return tiledbJNI.tiledb_query_get_est_result_size( SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), SWIGTYPE_p_tiledb_query_t.getCPtr(query), - attr_name, + name, SWIGTYPE_p_unsigned_long_long.getCPtr(size)); } public static int tiledb_query_get_est_result_size_var( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_query_t query, - String attr_name, + String name, SWIGTYPE_p_unsigned_long_long size_off, SWIGTYPE_p_unsigned_long_long size_val) { return tiledbJNI.tiledb_query_get_est_result_size_var( SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), SWIGTYPE_p_tiledb_query_t.getCPtr(query), - attr_name, + name, SWIGTYPE_p_unsigned_long_long.getCPtr(size_off), SWIGTYPE_p_unsigned_long_long.getCPtr(size_val)); } @@ -2481,6 +2587,14 @@ public static int tiledb_array_consolidate_with_key( SWIGTYPE_p_tiledb_config_t.getCPtr(config)); } + public static int tiledb_array_vacuum( + SWIGTYPE_p_tiledb_ctx_t ctx, String array_uri, SWIGTYPE_p_tiledb_config_t config) { + return tiledbJNI.tiledb_array_vacuum( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + array_uri, + SWIGTYPE_p_tiledb_config_t.getCPtr(config)); + } + public static int tiledb_array_get_non_empty_domain( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_array_t array, @@ -2493,16 +2607,108 @@ public static int tiledb_array_get_non_empty_domain( SWIGTYPE_p_int.getCPtr(is_empty)); } + public static int tiledb_array_get_non_empty_domain_from_index( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_t array, + long idx, + SWIGTYPE_p_void domain, + SWIGTYPE_p_int is_empty) { + return tiledbJNI.tiledb_array_get_non_empty_domain_from_index( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_t.getCPtr(array), + idx, + SWIGTYPE_p_void.getCPtr(domain), + SWIGTYPE_p_int.getCPtr(is_empty)); + } + + public static int tiledb_array_get_non_empty_domain_from_name( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_t array, + String name, + SWIGTYPE_p_void domain, + SWIGTYPE_p_int is_empty) { + return tiledbJNI.tiledb_array_get_non_empty_domain_from_name( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_t.getCPtr(array), + name, + SWIGTYPE_p_void.getCPtr(domain), + SWIGTYPE_p_int.getCPtr(is_empty)); + } + + public static int tiledb_array_get_non_empty_domain_var_size_from_index( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_t array, + long idx, + SWIGTYPE_p_unsigned_long_long start_size, + SWIGTYPE_p_unsigned_long_long end_size, + SWIGTYPE_p_int is_empty) { + return tiledbJNI.tiledb_array_get_non_empty_domain_var_size_from_index( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_t.getCPtr(array), + idx, + SWIGTYPE_p_unsigned_long_long.getCPtr(start_size), + SWIGTYPE_p_unsigned_long_long.getCPtr(end_size), + SWIGTYPE_p_int.getCPtr(is_empty)); + } + + public static int tiledb_array_get_non_empty_domain_var_size_from_name( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_t array, + String name, + SWIGTYPE_p_unsigned_long_long start_size, + SWIGTYPE_p_unsigned_long_long end_size, + SWIGTYPE_p_int is_empty) { + return tiledbJNI.tiledb_array_get_non_empty_domain_var_size_from_name( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_t.getCPtr(array), + name, + SWIGTYPE_p_unsigned_long_long.getCPtr(start_size), + SWIGTYPE_p_unsigned_long_long.getCPtr(end_size), + SWIGTYPE_p_int.getCPtr(is_empty)); + } + + public static int tiledb_array_get_non_empty_domain_var_from_index( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_t array, + long idx, + SWIGTYPE_p_void start, + SWIGTYPE_p_void end, + SWIGTYPE_p_int is_empty) { + return tiledbJNI.tiledb_array_get_non_empty_domain_var_from_index( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_t.getCPtr(array), + idx, + SWIGTYPE_p_void.getCPtr(start), + SWIGTYPE_p_void.getCPtr(end), + SWIGTYPE_p_int.getCPtr(is_empty)); + } + + public static int tiledb_array_get_non_empty_domain_var_from_name( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_t array, + String name, + SWIGTYPE_p_void start, + SWIGTYPE_p_void end, + SWIGTYPE_p_int is_empty) { + return tiledbJNI.tiledb_array_get_non_empty_domain_var_from_name( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_t.getCPtr(array), + name, + SWIGTYPE_p_void.getCPtr(start), + SWIGTYPE_p_void.getCPtr(end), + SWIGTYPE_p_int.getCPtr(is_empty)); + } + public static int tiledb_array_max_buffer_size( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_array_t array, - String attribute, + String name, SWIGTYPE_p_void subarray, SWIGTYPE_p_unsigned_long_long buffer_size) { return tiledbJNI.tiledb_array_max_buffer_size( SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), SWIGTYPE_p_tiledb_array_t.getCPtr(array), - attribute, + name, SWIGTYPE_p_void.getCPtr(subarray), SWIGTYPE_p_unsigned_long_long.getCPtr(buffer_size)); } @@ -2510,14 +2716,14 @@ public static int tiledb_array_max_buffer_size( public static int tiledb_array_max_buffer_size_var( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_array_t array, - String attribute, + String name, SWIGTYPE_p_void subarray, SWIGTYPE_p_unsigned_long_long buffer_off_size, SWIGTYPE_p_unsigned_long_long buffer_val_size) { return tiledbJNI.tiledb_array_max_buffer_size_var( SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), SWIGTYPE_p_tiledb_array_t.getCPtr(array), - attribute, + name, SWIGTYPE_p_void.getCPtr(subarray), SWIGTYPE_p_unsigned_long_long.getCPtr(buffer_off_size), SWIGTYPE_p_unsigned_long_long.getCPtr(buffer_val_size)); diff --git a/src/main/java/io/tiledb/libtiledb/tiledbConstants.java b/src/main/java/io/tiledb/libtiledb/tiledbConstants.java index e669e4a6..60cb558f 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledbConstants.java +++ b/src/main/java/io/tiledb/libtiledb/tiledbConstants.java @@ -12,7 +12,7 @@ public interface tiledbConstants { public static final int TILEDB_ERR = (-1); public static final int TILEDB_OK = 0; public static final int TILEDB_OOM = (-2); - public static final int TILEDB_VERSION_MAJOR = 1; - public static final int TILEDB_VERSION_MINOR = 7; - public static final int TILEDB_VERSION_PATCH = 7; + public static final int TILEDB_VERSION_MAJOR = 2; + public static final int TILEDB_VERSION_MINOR = 0; + public static final int TILEDB_VERSION_PATCH = 0; } diff --git a/src/main/java/io/tiledb/libtiledb/tiledbJNI.java b/src/main/java/io/tiledb/libtiledb/tiledbJNI.java index e5f1c017..6bebbe9f 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledbJNI.java +++ b/src/main/java/io/tiledb/libtiledb/tiledbJNI.java @@ -818,6 +818,18 @@ public static final native int tiledb_dimension_alloc( public static final native void tiledb_dimension_free(long jarg1); + public static final native int tiledb_dimension_set_filter_list( + long jarg1, long jarg2, long jarg3); + + public static final native int tiledb_dimension_set_cell_val_num( + long jarg1, long jarg2, long jarg3); + + public static final native int tiledb_dimension_get_filter_list( + long jarg1, long jarg2, long jarg3); + + public static final native int tiledb_dimension_get_cell_val_num( + long jarg1, long jarg2, long jarg3); + public static final native int tiledb_dimension_get_name(long jarg1, long jarg2, long jarg3); public static final native int tiledb_dimension_get_type(long jarg1, long jarg2, long jarg3); @@ -836,6 +848,12 @@ public static final native int tiledb_dimension_get_tile_extent( public static final native int tiledb_array_schema_add_attribute( long jarg1, long jarg2, long jarg3); + public static final native int tiledb_array_schema_set_allows_dups( + long jarg1, long jarg2, int jarg3); + + public static final native int tiledb_array_schema_get_allows_dups( + long jarg1, long jarg2, long jarg3); + public static final native int tiledb_array_schema_set_domain(long jarg1, long jarg2, long jarg3); public static final native int tiledb_array_schema_set_capacity( @@ -932,6 +950,15 @@ public static final native int tiledb_query_submit_async( public static final native int tiledb_query_add_range( long jarg1, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6); + public static final native int tiledb_query_add_range_var( + long jarg1, + long jarg2, + long jarg3, + long jarg4, + java.math.BigInteger jarg5, + long jarg6, + java.math.BigInteger jarg7); + public static final native int tiledb_query_get_range_num( long jarg1, long jarg2, long jarg3, long jarg4); @@ -944,6 +971,12 @@ public static final native int tiledb_query_get_range( long jarg6, long jarg7); + public static final native int tiledb_query_get_range_var_size( + long jarg1, long jarg2, long jarg3, java.math.BigInteger jarg4, long jarg5, long jarg6); + + public static final native int tiledb_query_get_range_var( + long jarg1, long jarg2, long jarg3, java.math.BigInteger jarg4, long jarg5, long jarg6); + public static final native int tiledb_query_get_est_result_size( long jarg1, long jarg2, String jarg3, long jarg4); @@ -1004,9 +1037,29 @@ public static final native int tiledb_array_create_with_key( public static final native int tiledb_array_consolidate_with_key( long jarg1, String jarg2, int jarg3, long jarg4, long jarg5, long jarg6); + public static final native int tiledb_array_vacuum(long jarg1, String jarg2, long jarg3); + public static final native int tiledb_array_get_non_empty_domain( long jarg1, long jarg2, long jarg3, long jarg4); + public static final native int tiledb_array_get_non_empty_domain_from_index( + long jarg1, long jarg2, long jarg3, long jarg4, long jarg5); + + public static final native int tiledb_array_get_non_empty_domain_from_name( + long jarg1, long jarg2, String jarg3, long jarg4, long jarg5); + + public static final native int tiledb_array_get_non_empty_domain_var_size_from_index( + long jarg1, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6); + + public static final native int tiledb_array_get_non_empty_domain_var_size_from_name( + long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6); + + public static final native int tiledb_array_get_non_empty_domain_var_from_index( + long jarg1, long jarg2, long jarg3, long jarg4, long jarg5, long jarg6); + + public static final native int tiledb_array_get_non_empty_domain_var_from_name( + long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6); + public static final native int tiledb_array_max_buffer_size( long jarg1, long jarg2, String jarg3, long jarg4, long jarg5); diff --git a/src/main/java/io/tiledb/libtiledb/tiledb_filesystem_t.java b/src/main/java/io/tiledb/libtiledb/tiledb_filesystem_t.java index 7952a0b8..44ae0076 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledb_filesystem_t.java +++ b/src/main/java/io/tiledb/libtiledb/tiledb_filesystem_t.java @@ -10,7 +10,9 @@ public enum tiledb_filesystem_t { TILEDB_HDFS(0), - TILEDB_S3(1); + TILEDB_S3(1), + TILEDB_AZURE(2), + TILEDB_GCS(3); public final int swigValue() { return swigValue; diff --git a/src/main/java/io/tiledb/libtiledb/tiledb_filter_type_t.java b/src/main/java/io/tiledb/libtiledb/tiledb_filter_type_t.java index f4092343..c5c5c769 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledb_filter_type_t.java +++ b/src/main/java/io/tiledb/libtiledb/tiledb_filter_type_t.java @@ -19,7 +19,9 @@ public enum tiledb_filter_type_t { TILEDB_FILTER_BIT_WIDTH_REDUCTION(7), TILEDB_FILTER_BITSHUFFLE(8), TILEDB_FILTER_BYTESHUFFLE(9), - TILEDB_FILTER_POSITIVE_DELTA(10); + TILEDB_FILTER_POSITIVE_DELTA(10), + TILEDB_FILTER_CHECKSUM_MD5(12), + TILEDB_FILTER_CHECKSUM_SHA256(13); public final int swigValue() { return swigValue; diff --git a/src/test/java/io/tiledb/java/api/VersionTest.java b/src/test/java/io/tiledb/java/api/VersionTest.java index 30421191..a00f1227 100644 --- a/src/test/java/io/tiledb/java/api/VersionTest.java +++ b/src/test/java/io/tiledb/java/api/VersionTest.java @@ -32,8 +32,9 @@ public class VersionTest { @Test public void testVersion() { Version version = new Version(); - Assert.assertTrue(version.getMajor() >= 1); - Assert.assertTrue(version.getMinor() >= 3); + System.out.println(version); + Assert.assertTrue(version.getMajor() >= 2); + Assert.assertTrue(version.getMinor() >= 0); Assert.assertTrue(version.getRevision() >= 0); } } From cc478852d0fff9172c5c0909ad3935bff0b1b6b1 Mon Sep 17 00:00:00 2001 From: gsvic Date: Wed, 29 Apr 2020 19:20:33 +0300 Subject: [PATCH 2/2] added unit test for reading dimensions using getBuffer --- .../java/io/tiledb/java/api/QueryTest.java | 72 ++++++++++++++----- 1 file changed, 56 insertions(+), 16 deletions(-) diff --git a/src/test/java/io/tiledb/java/api/QueryTest.java b/src/test/java/io/tiledb/java/api/QueryTest.java index 849d28fe..5533c615 100644 --- a/src/test/java/io/tiledb/java/api/QueryTest.java +++ b/src/test/java/io/tiledb/java/api/QueryTest.java @@ -35,11 +35,6 @@ public void teardown() throws Exception { } } - @Test - public void test() throws Exception { - arrayRead(); - } - public void arrayCreate() throws Exception { // The array will be 4x4 with dimensions "rows" and "cols", with domain [1,4]. Dimension rows = @@ -94,30 +89,33 @@ public void arrayWrite() throws Exception { array.close(); } - private void arrayRead() throws Exception { + @Test + public void arrayReadTest() throws Exception { Array array = new Array(ctx, arrayURI, TILEDB_READ); // Create query Query query = new Query(array, TILEDB_READ); // Slice only rows 1, 2 and cols 2, 3, 4 - query.addRange(0, (int) 1, (int) 2); - query.addRange(1, (int) 2, (int) 4); + query.addRange(0, 1, 2); + query.addRange(1, 2, 4); query.setLayout(TILEDB_ROW_MAJOR); // Prepare the vector that will hold the result // (of size 6 elements for "a1" and 12 elements for "a2" since // it stores two floats per cell) - NativeArray a1Array = new NativeArray(ctx, 6, Character.class); - NativeArray a2Array = new NativeArray(ctx, 12, Float.class); + // Get the first 6 elements of each attribute/dimension + NativeArray dim1Array = new NativeArray(ctx, 6, Integer.class); + NativeArray dim2Array = new NativeArray(ctx, 6, Integer.class); + NativeArray a1Array = new NativeArray(ctx, 12, Character.class); + NativeArray a2Array = new NativeArray(ctx, 6, Float.class); + + query.setBuffer("rows", dim1Array); + query.setBuffer("cols", dim2Array); query.setBuffer("a1", a1Array); query.setBuffer("a2", a2Array); - // set the number of buffer elements to a size smaller than the read buffer size - query.setBufferElements("a1", 3); - query.setBufferElements("a2", 6); - // Submit query query.submit(); @@ -126,16 +124,58 @@ private void arrayRead() throws Exception { Assert.assertEquals(Long.valueOf(3), resultElements.get("a1").getSecond()); Assert.assertEquals(Long.valueOf(6), resultElements.get("a2").getSecond()); + int[] dim1 = (int[]) query.getBuffer("rows"); + int[] dim2 = (int[]) query.getBuffer("cols"); byte[] a1 = (byte[]) query.getBuffer("a1"); float[] a2 = (float[]) query.getBuffer("a2"); + Assert.assertArrayEquals(new int[] {1, 1, 1}, dim1); + Assert.assertArrayEquals(new int[] {2, 3, 4}, dim2); Assert.assertArrayEquals(new byte[] {'b', 'c', 'd'}, a1); - float[] expected_a2 = new float[] {1.1f, 1.2f, 2.1f, 2.2f, 3.1f, 3.2f}; - Assert.assertArrayEquals(expected_a2, a2, 0.01f); + Assert.assertArrayEquals(new float[] {1.1f, 1.2f, 2.1f, 2.2f, 3.1f, 3.2f}, a2, 0.01f); + dim1Array.close(); + dim2Array.close(); a1Array.close(); a2Array.close(); query.close(); array.close(); } + + @Test + public void arrayReadDimensionsTest() throws Exception { + Array array = new Array(ctx, arrayURI, TILEDB_READ); + + Query query = new Query(array, TILEDB_READ); + + query.addRange(0, 1, 4); + query.addRange(1, 1, 4); + query.setLayout(TILEDB_ROW_MAJOR); + + // Get the first 6 elements of each attribute/dimension + NativeArray dim1Array = new NativeArray(ctx, 16, Integer.class); + NativeArray dim2Array = new NativeArray(ctx, 16, Integer.class); + + query.setBuffer("rows", dim1Array); + query.setBuffer("cols", dim2Array); + + // Submit query + query.submit(); + + HashMap> resultElements = query.resultBufferElements(); + + Assert.assertEquals(Long.valueOf(16), resultElements.get("rows").getSecond()); + Assert.assertEquals(Long.valueOf(16), resultElements.get("cols").getSecond()); + + int[] dim1 = (int[]) query.getBuffer("rows"); + int[] dim2 = (int[]) query.getBuffer("cols"); + + Assert.assertArrayEquals(new int[] {1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4}, dim1); + Assert.assertArrayEquals(new int[] {1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}, dim2); + + query.close(); + array.close(); + dim1Array.close(); + dim2Array.close(); + } }