From 5b697e2f7295e7e9b063c5c2b379116b46bb21ec Mon Sep 17 00:00:00 2001 From: dimitrisstaratzis Date: Mon, 29 Jul 2024 18:31:18 +0300 Subject: [PATCH 1/4] Add support for the CurrentDomain feature --- src/main/c/generated/tiledb_wrap.cxx | 882 +++++++++++++++++- .../io/tiledb/java/api/CurrentDomain.java | 3 + .../java/io/tiledb/java/api/NDRectangle.java | 43 + src/main/java/io/tiledb/java/api/Range.java | 61 ++ .../SWIGTYPE_p_p_tiledb_current_domain_t.java | 30 + .../SWIGTYPE_p_p_tiledb_ndrectangle_t.java | 30 + .../SWIGTYPE_p_p_tiledb_range_t.java | 29 + .../SWIGTYPE_p_tiledb_current_domain_t.java | 30 + ...IGTYPE_p_tiledb_current_domain_type_t.java | 30 + .../SWIGTYPE_p_tiledb_ndrectangle_t.java | 30 + src/main/java/io/tiledb/libtiledb/tiledb.java | 279 ++++++ .../io/tiledb/libtiledb/tiledbConstants.java | 2 +- .../java/io/tiledb/libtiledb/tiledbJNI.java | 104 +++ .../tiledb_current_domain_type_t.java | 52 ++ .../io/tiledb/libtiledb/tiledb_range_t.java | 88 ++ .../io/tiledb/java/api/CurrentDomainTest.java | 21 + swig/tiledb.i | 7 +- 17 files changed, 1691 insertions(+), 30 deletions(-) create mode 100644 src/main/java/io/tiledb/java/api/CurrentDomain.java create mode 100644 src/main/java/io/tiledb/java/api/NDRectangle.java create mode 100644 src/main/java/io/tiledb/java/api/Range.java create mode 100644 src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_current_domain_t.java create mode 100644 src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_ndrectangle_t.java create mode 100644 src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_range_t.java create mode 100644 src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_current_domain_t.java create mode 100644 src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_current_domain_type_t.java create mode 100644 src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_ndrectangle_t.java create mode 100644 src/main/java/io/tiledb/libtiledb/tiledb_current_domain_type_t.java create mode 100644 src/main/java/io/tiledb/libtiledb/tiledb_range_t.java create mode 100644 src/test/java/io/tiledb/java/api/CurrentDomainTest.java diff --git a/src/main/c/generated/tiledb_wrap.cxx b/src/main/c/generated/tiledb_wrap.cxx index ad3801c6..1ef89642 100644 --- a/src/main/c/generated/tiledb_wrap.cxx +++ b/src/main/c/generated/tiledb_wrap.cxx @@ -1037,6 +1037,27 @@ static tiledb_field_origin_t tiledb_field_origin_tp_value(tiledb_field_origin_t } +static tiledb_current_domain_type_t *new_tiledb_current_domain_type_tp(void) { + return new tiledb_current_domain_type_t(); +} + +static tiledb_current_domain_type_t *copy_tiledb_current_domain_type_tp(tiledb_current_domain_type_t value) { + return new tiledb_current_domain_type_t(value); +} + +static void delete_tiledb_current_domain_type_tp(tiledb_current_domain_type_t *obj) { + delete obj; +} + +static void tiledb_current_domain_type_tp_assign(tiledb_current_domain_type_t *obj, tiledb_current_domain_type_t value) { + *obj = value; +} + +static tiledb_current_domain_type_t tiledb_current_domain_type_tp_value(tiledb_current_domain_type_t *obj) { + return *obj; +} + + static tiledb_array_t* *new_tiledb_array_tpp(void) { return new tiledb_array_t*(); } @@ -1604,6 +1625,69 @@ static tiledb_query_channel_t* tiledb_query_channel_tpp_value(tiledb_query_chann } +static tiledb_ndrectangle_t* *new_tiledb_ndrectangle_tpp(void) { + return new tiledb_ndrectangle_t*(); +} + +static tiledb_ndrectangle_t* *copy_tiledb_ndrectangle_tpp(tiledb_ndrectangle_t* value) { + return new tiledb_ndrectangle_t*(value); +} + +static void delete_tiledb_ndrectangle_tpp(tiledb_ndrectangle_t* *obj) { + delete obj; +} + +static void tiledb_ndrectangle_tpp_assign(tiledb_ndrectangle_t* *obj, tiledb_ndrectangle_t* value) { + *obj = value; +} + +static tiledb_ndrectangle_t* tiledb_ndrectangle_tpp_value(tiledb_ndrectangle_t* *obj) { + return *obj; +} + + +static tiledb_current_domain_t* *new_tiledb_current_domain_tpp(void) { + return new tiledb_current_domain_t*(); +} + +static tiledb_current_domain_t* *copy_tiledb_current_domain_tpp(tiledb_current_domain_t* value) { + return new tiledb_current_domain_t*(value); +} + +static void delete_tiledb_current_domain_tpp(tiledb_current_domain_t* *obj) { + delete obj; +} + +static void tiledb_current_domain_tpp_assign(tiledb_current_domain_t* *obj, tiledb_current_domain_t* value) { + *obj = value; +} + +static tiledb_current_domain_t* tiledb_current_domain_tpp_value(tiledb_current_domain_t* *obj) { + return *obj; +} + + +static tiledb_range_t* *new_tiledb_range_tpp(void) { + return new tiledb_range_t*(); +} + +static tiledb_range_t* *copy_tiledb_range_tpp(tiledb_range_t* value) { + return new tiledb_range_t*(value); +} + +static void delete_tiledb_range_tpp(tiledb_range_t* *obj) { + delete obj; +} + +static void tiledb_range_tpp_assign(tiledb_range_t* *obj, tiledb_range_t* value) { + *obj = value; +} + +static tiledb_range_t* tiledb_range_tpp_value(tiledb_range_t* *obj) { + return *obj; +} + + static tiledb_array_schema_evolution_t* *new_tiledb_array_schema_evolution_tpp(void) { return new tiledb_array_schema_evolution_t*(); } @@ -4382,6 +4466,68 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1field_1origin } +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_new_1tiledb_1current_1domain_1type_1tp(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + tiledb_current_domain_type_t *result = 0 ; + + (void)jenv; + (void)jcls; + result = (tiledb_current_domain_type_t *)new_tiledb_current_domain_type_tp(); + *(tiledb_current_domain_type_t **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_copy_1tiledb_1current_1domain_1type_1tp(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + tiledb_current_domain_type_t arg1 ; + tiledb_current_domain_type_t *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (tiledb_current_domain_type_t)jarg1; + result = (tiledb_current_domain_type_t *)copy_tiledb_current_domain_type_tp(arg1); + *(tiledb_current_domain_type_t **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_delete_1tiledb_1current_1domain_1type_1tp(JNIEnv *jenv, jclass jcls, jlong jarg1) { + tiledb_current_domain_type_t *arg1 = (tiledb_current_domain_type_t *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_type_t **)&jarg1; + delete_tiledb_current_domain_type_tp(arg1); +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1type_1tp_1assign(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + tiledb_current_domain_type_t *arg1 = (tiledb_current_domain_type_t *) 0 ; + tiledb_current_domain_type_t arg2 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_type_t **)&jarg1; + arg2 = (tiledb_current_domain_type_t)jarg2; + tiledb_current_domain_type_tp_assign(arg1,arg2); +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1type_1tp_1value(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + tiledb_current_domain_type_t *arg1 = (tiledb_current_domain_type_t *) 0 ; + tiledb_current_domain_type_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_type_t **)&jarg1; + result = (tiledb_current_domain_type_t)tiledb_current_domain_type_tp_value(arg1); + jresult = (jint)result; + return jresult; +} + + SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_new_1tiledb_1array_1tpp(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; tiledb_array_t **result = 0 ; @@ -6058,6 +6204,194 @@ SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1chann } +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_new_1tiledb_1ndrectangle_1tpp(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + tiledb_ndrectangle_t **result = 0 ; + + (void)jenv; + (void)jcls; + result = (tiledb_ndrectangle_t **)new_tiledb_ndrectangle_tpp(); + *(tiledb_ndrectangle_t ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_copy_1tiledb_1ndrectangle_1tpp(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + tiledb_ndrectangle_t *arg1 = (tiledb_ndrectangle_t *) 0 ; + tiledb_ndrectangle_t **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ndrectangle_t **)&jarg1; + result = (tiledb_ndrectangle_t **)copy_tiledb_ndrectangle_tpp(arg1); + *(tiledb_ndrectangle_t ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_delete_1tiledb_1ndrectangle_1tpp(JNIEnv *jenv, jclass jcls, jlong jarg1) { + tiledb_ndrectangle_t **arg1 = (tiledb_ndrectangle_t **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ndrectangle_t ***)&jarg1; + delete_tiledb_ndrectangle_tpp(arg1); +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1ndrectangle_1tpp_1assign(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + tiledb_ndrectangle_t **arg1 = (tiledb_ndrectangle_t **) 0 ; + tiledb_ndrectangle_t *arg2 = (tiledb_ndrectangle_t *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ndrectangle_t ***)&jarg1; + arg2 = *(tiledb_ndrectangle_t **)&jarg2; + tiledb_ndrectangle_tpp_assign(arg1,arg2); +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1ndrectangle_1tpp_1value(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + tiledb_ndrectangle_t **arg1 = (tiledb_ndrectangle_t **) 0 ; + tiledb_ndrectangle_t *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ndrectangle_t ***)&jarg1; + result = (tiledb_ndrectangle_t *)tiledb_ndrectangle_tpp_value(arg1); + *(tiledb_ndrectangle_t **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_new_1tiledb_1current_1domain_1tpp(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + tiledb_current_domain_t **result = 0 ; + + (void)jenv; + (void)jcls; + result = (tiledb_current_domain_t **)new_tiledb_current_domain_tpp(); + *(tiledb_current_domain_t ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_copy_1tiledb_1current_1domain_1tpp(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + tiledb_current_domain_t *arg1 = (tiledb_current_domain_t *) 0 ; + tiledb_current_domain_t **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_t **)&jarg1; + result = (tiledb_current_domain_t **)copy_tiledb_current_domain_tpp(arg1); + *(tiledb_current_domain_t ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_delete_1tiledb_1current_1domain_1tpp(JNIEnv *jenv, jclass jcls, jlong jarg1) { + tiledb_current_domain_t **arg1 = (tiledb_current_domain_t **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_t ***)&jarg1; + delete_tiledb_current_domain_tpp(arg1); +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1tpp_1assign(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + tiledb_current_domain_t **arg1 = (tiledb_current_domain_t **) 0 ; + tiledb_current_domain_t *arg2 = (tiledb_current_domain_t *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_t ***)&jarg1; + arg2 = *(tiledb_current_domain_t **)&jarg2; + tiledb_current_domain_tpp_assign(arg1,arg2); +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1tpp_1value(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + tiledb_current_domain_t **arg1 = (tiledb_current_domain_t **) 0 ; + tiledb_current_domain_t *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_t ***)&jarg1; + result = (tiledb_current_domain_t *)tiledb_current_domain_tpp_value(arg1); + *(tiledb_current_domain_t **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_new_1tiledb_1range_1tpp(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + tiledb_range_t **result = 0 ; + + (void)jenv; + (void)jcls; + result = (tiledb_range_t **)new_tiledb_range_tpp(); + *(tiledb_range_t ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_copy_1tiledb_1range_1tpp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + tiledb_range_t **result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(tiledb_range_t **)&jarg1; + result = (tiledb_range_t **)copy_tiledb_range_tpp(arg1); + *(tiledb_range_t ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_delete_1tiledb_1range_1tpp(JNIEnv *jenv, jclass jcls, jlong jarg1) { + tiledb_range_t **arg1 = (tiledb_range_t **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_range_t ***)&jarg1; + delete_tiledb_range_tpp(arg1); +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1tpp_1assign(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jobject jarg2_) { + tiledb_range_t **arg1 = (tiledb_range_t **) 0 ; + tiledb_range_t *arg2 = (tiledb_range_t *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = *(tiledb_range_t ***)&jarg1; + arg2 = *(tiledb_range_t **)&jarg2; + tiledb_range_tpp_assign(arg1,arg2); +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1tpp_1value(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + tiledb_range_t **arg1 = (tiledb_range_t **) 0 ; + tiledb_range_t *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_range_t ***)&jarg1; + result = (tiledb_range_t *)tiledb_range_tpp_value(arg1); + *(tiledb_range_t **)&jresult = result; + return jresult; +} + + SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_new_1tiledb_1array_1schema_1evolution_1tpp(JNIEnv *jenv, jclass jcls) { jlong jresult = 0 ; tiledb_array_schema_evolution_t **result = 0 ; @@ -13963,32 +14297,42 @@ SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1attribute_1g } -SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1enumeration_1alloc(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jint jarg5, jlong jarg6, jobject jarg7, jlong jarg8, jobject jarg9, jlong jarg10) { +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1t_1min_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + void *arg2 = (void *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(tiledb_range_t **)&jarg1; + arg2 = *(void **)&jarg2; + if (arg1) (arg1)->min = (void const *)arg2; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1t_1min_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { jlong jresult = 0 ; - tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; - char *arg2 = (char *) 0 ; - tiledb_datatype_t arg3 ; - uint32_t arg4 ; - int arg5 ; - void *arg6 = (void *) 0 ; - uint64_t arg7 ; - void *arg8 = (void *) 0 ; - uint64_t arg9 ; - tiledb_enumeration_t **arg10 = (tiledb_enumeration_t **) 0 ; - SwigValueWrapper< capi_return_t > result; + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + void *result = 0 ; (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_datatype_t)jarg3; - arg4 = (uint32_t)jarg4; - arg5 = (int)jarg5; - arg6 = *(void **)&jarg6; + (void)jarg1_; + arg1 = *(tiledb_range_t **)&jarg1; + result = (void *) ((arg1)->min); + *(void **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1t_1min_1size_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + uint64_t arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(tiledb_range_t **)&jarg1; { jclass clazz; jmethodID mid; @@ -13997,18 +14341,446 @@ SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1enumeration_ jsize sz; int i; - if (!jarg7) { + if (!jarg2) { SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null"); - return 0; + return ; } - clazz = jenv->GetObjectClass(jarg7); + clazz = jenv->GetObjectClass(jarg2); mid = jenv->GetMethodID(clazz, "toByteArray", "()[B"); - ba = (jbyteArray)jenv->CallObjectMethod(jarg7, mid); + ba = (jbyteArray)jenv->CallObjectMethod(jarg2, mid); bae = jenv->GetByteArrayElements(ba, 0); sz = jenv->GetArrayLength(ba); - arg7 = 0; + arg2 = 0; if (sz > 0) { - arg7 = (uint64_t)(signed char)bae[0]; + arg2 = (uint64_t)(signed char)bae[0]; + for(i=1; iReleaseByteArrayElements(ba, bae, 0); + } + if (arg1) (arg1)->min_size = arg2; +} + + +SWIGEXPORT jobject JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1t_1min_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jobject jresult = 0 ; + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + uint64_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(tiledb_range_t **)&jarg1; + result = (uint64_t) ((arg1)->min_size); + { + jbyteArray ba = jenv->NewByteArray(9); + jbyte* bae = jenv->GetByteArrayElements(ba, 0); + jclass clazz = jenv->FindClass("java/math/BigInteger"); + jmethodID mid = jenv->GetMethodID(clazz, "", "([B)V"); + jobject bigint; + int i; + + bae[0] = 0; + for(i=1; i<9; i++ ) { + bae[i] = (jbyte)(result>>8*(8-i)); + } + + jenv->ReleaseByteArrayElements(ba, bae, 0); + bigint = jenv->NewObject(clazz, mid, ba); + jenv->DeleteLocalRef(ba); + jresult = bigint; + } + return jresult; +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1t_1max_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + void *arg2 = (void *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(tiledb_range_t **)&jarg1; + arg2 = *(void **)&jarg2; + if (arg1) (arg1)->max = (void const *)arg2; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1t_1max_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + void *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(tiledb_range_t **)&jarg1; + result = (void *) ((arg1)->max); + *(void **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1t_1max_1size_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + uint64_t arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(tiledb_range_t **)&jarg1; + { + jclass clazz; + jmethodID mid; + jbyteArray ba; + jbyte* bae; + jsize sz; + int i; + + if (!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null"); + return ; + } + clazz = jenv->GetObjectClass(jarg2); + mid = jenv->GetMethodID(clazz, "toByteArray", "()[B"); + ba = (jbyteArray)jenv->CallObjectMethod(jarg2, mid); + bae = jenv->GetByteArrayElements(ba, 0); + sz = jenv->GetArrayLength(ba); + arg2 = 0; + if (sz > 0) { + arg2 = (uint64_t)(signed char)bae[0]; + for(i=1; iReleaseByteArrayElements(ba, bae, 0); + } + if (arg1) (arg1)->max_size = arg2; +} + + +SWIGEXPORT jobject JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1range_1t_1max_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jobject jresult = 0 ; + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + uint64_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(tiledb_range_t **)&jarg1; + result = (uint64_t) ((arg1)->max_size); + { + jbyteArray ba = jenv->NewByteArray(9); + jbyte* bae = jenv->GetByteArrayElements(ba, 0); + jclass clazz = jenv->FindClass("java/math/BigInteger"); + jmethodID mid = jenv->GetMethodID(clazz, "", "([B)V"); + jobject bigint; + int i; + + bae[0] = 0; + for(i=1; i<9; i++ ) { + bae[i] = (jbyte)(result>>8*(8-i)); + } + + jenv->ReleaseByteArrayElements(ba, bae, 0); + bigint = jenv->NewObject(clazz, mid, ba); + jenv->DeleteLocalRef(ba); + jresult = bigint; + } + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_new_1tiledb_1range_1t(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + tiledb_range_t *result = 0 ; + + (void)jenv; + (void)jcls; + result = (tiledb_range_t *)new tiledb_range_t(); + *(tiledb_range_t **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_io_tiledb_libtiledb_tiledbJNI_delete_1tiledb_1range_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) { + tiledb_range_t *arg1 = (tiledb_range_t *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_range_t **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1ndrectangle_1alloc(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_domain_t *arg2 = (tiledb_domain_t *) 0 ; + tiledb_ndrectangle_t **arg3 = (tiledb_ndrectangle_t **) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_domain_t **)&jarg2; + arg3 = *(tiledb_ndrectangle_t ***)&jarg3; + result = tiledb_ndrectangle_alloc(arg1,arg2,arg3); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1ndrectangle_1free(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + tiledb_ndrectangle_t **arg1 = (tiledb_ndrectangle_t **) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ndrectangle_t ***)&jarg1; + result = tiledb_ndrectangle_free(arg1); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1ndrectangle_1get_1range_1from_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jobject jarg4_) { + jlong jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_ndrectangle_t *arg2 = (tiledb_ndrectangle_t *) 0 ; + char *arg3 = (char *) 0 ; + tiledb_range_t *arg4 = (tiledb_range_t *) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + (void)jarg4_; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_ndrectangle_t **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(tiledb_range_t **)&jarg4; + result = tiledb_ndrectangle_get_range_from_name(arg1,arg2,(char const *)arg3,arg4); + *(capi_return_t **)&jresult = new capi_return_t(result); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1ndrectangle_1get_1range(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) { + jlong jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_ndrectangle_t *arg2 = (tiledb_ndrectangle_t *) 0 ; + uint32_t arg3 ; + tiledb_range_t *arg4 = (tiledb_range_t *) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + (void)jarg4_; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_ndrectangle_t **)&jarg2; + arg3 = (uint32_t)jarg3; + arg4 = *(tiledb_range_t **)&jarg4; + result = tiledb_ndrectangle_get_range(arg1,arg2,arg3,arg4); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1ndrectangle_1set_1range_1for_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jobject jarg4_) { + jlong jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_ndrectangle_t *arg2 = (tiledb_ndrectangle_t *) 0 ; + char *arg3 = (char *) 0 ; + tiledb_range_t *arg4 = (tiledb_range_t *) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + (void)jarg4_; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_ndrectangle_t **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(tiledb_range_t **)&jarg4; + result = tiledb_ndrectangle_set_range_for_name(arg1,arg2,(char const *)arg3,arg4); + *(capi_return_t **)&jresult = new capi_return_t(result); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1ndrectangle_1set_1range(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) { + jlong jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_ndrectangle_t *arg2 = (tiledb_ndrectangle_t *) 0 ; + uint32_t arg3 ; + tiledb_range_t *arg4 = (tiledb_range_t *) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + (void)jarg4_; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_ndrectangle_t **)&jarg2; + arg3 = (uint32_t)jarg3; + arg4 = *(tiledb_range_t **)&jarg4; + result = tiledb_ndrectangle_set_range(arg1,arg2,arg3,arg4); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1create(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_current_domain_t **arg2 = (tiledb_current_domain_t **) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_current_domain_t ***)&jarg2; + result = tiledb_current_domain_create(arg1,arg2); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1free(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + tiledb_current_domain_t **arg1 = (tiledb_current_domain_t **) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_t ***)&jarg1; + result = tiledb_current_domain_free(arg1); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1set_1ndrectangle(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + tiledb_current_domain_t *arg1 = (tiledb_current_domain_t *) 0 ; + tiledb_ndrectangle_t *arg2 = (tiledb_ndrectangle_t *) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_t **)&jarg1; + arg2 = *(tiledb_ndrectangle_t **)&jarg2; + result = tiledb_current_domain_set_ndrectangle(arg1,arg2); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1get_1ndrectangle(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + tiledb_current_domain_t *arg1 = (tiledb_current_domain_t *) 0 ; + tiledb_ndrectangle_t **arg2 = (tiledb_ndrectangle_t **) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_t **)&jarg1; + arg2 = *(tiledb_ndrectangle_t ***)&jarg2; + result = tiledb_current_domain_get_ndrectangle(arg1,arg2); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1get_1is_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + tiledb_current_domain_t *arg1 = (tiledb_current_domain_t *) 0 ; + uint32_t *arg2 = (uint32_t *) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_t **)&jarg1; + arg2 = *(uint32_t **)&jarg2; + result = tiledb_current_domain_get_is_empty(arg1,arg2); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1current_1domain_1get_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + tiledb_current_domain_t *arg1 = (tiledb_current_domain_t *) 0 ; + tiledb_current_domain_type_t *arg2 = (tiledb_current_domain_type_t *) 0 ; + SwigValueWrapper< capi_return_t > result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_current_domain_t **)&jarg1; + arg2 = *(tiledb_current_domain_type_t **)&jarg2; + result = tiledb_current_domain_get_type(arg1,arg2); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1enumeration_1alloc(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jint jarg3, jlong jarg4, jint jarg5, jlong jarg6, jobject jarg7, jlong jarg8, jobject jarg9, jlong jarg10) { + jlong jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + char *arg2 = (char *) 0 ; + tiledb_datatype_t arg3 ; + uint32_t arg4 ; + int arg5 ; + void *arg6 = (void *) 0 ; + uint64_t arg7 ; + void *arg8 = (void *) 0 ; + uint64_t arg9 ; + tiledb_enumeration_t **arg10 = (tiledb_enumeration_t **) 0 ; + SwigValueWrapper< capi_return_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_datatype_t)jarg3; + arg4 = (uint32_t)jarg4; + arg5 = (int)jarg5; + 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; i result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_schema_evolution_t **)&jarg2; + arg3 = *(tiledb_current_domain_t **)&jarg3; + result = tiledb_array_schema_evolution_expand_current_domain(arg1,arg2,arg3); + *(capi_return_t **)&jresult = new capi_return_t(result); + return jresult; +} + + SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1schema_1timestamp_1range(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { jint jresult = 0 ; tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; @@ -15560,6 +16350,42 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1schema } +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1schema_1set_1current_1domain(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 ; + tiledb_current_domain_t *arg3 = (tiledb_current_domain_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_schema_t **)&jarg2; + arg3 = *(tiledb_current_domain_t **)&jarg3; + result = (int32_t)tiledb_array_schema_set_current_domain(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1schema_1get_1current_1domain(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 ; + tiledb_current_domain_t **arg3 = (tiledb_current_domain_t **) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_array_schema_t **)&jarg2; + arg3 = *(tiledb_current_domain_t ***)&jarg3; + result = (int32_t)tiledb_array_schema_get_current_domain(arg1,arg2,arg3); + jresult = (jint)result; + return jresult; +} + + SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1array_1evolve(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { jint jresult = 0 ; tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; diff --git a/src/main/java/io/tiledb/java/api/CurrentDomain.java b/src/main/java/io/tiledb/java/api/CurrentDomain.java new file mode 100644 index 00000000..ea0c9bc6 --- /dev/null +++ b/src/main/java/io/tiledb/java/api/CurrentDomain.java @@ -0,0 +1,3 @@ +package io.tiledb.java.api; + +public class CurrentDomain {} diff --git a/src/main/java/io/tiledb/java/api/NDRectangle.java b/src/main/java/io/tiledb/java/api/NDRectangle.java new file mode 100644 index 00000000..7747badd --- /dev/null +++ b/src/main/java/io/tiledb/java/api/NDRectangle.java @@ -0,0 +1,43 @@ +package io.tiledb.java.api; + +import io.tiledb.libtiledb.SWIGTYPE_p_p_tiledb_ndrectangle_t; +import io.tiledb.libtiledb.SWIGTYPE_p_tiledb_ndrectangle_t; +import io.tiledb.libtiledb.tiledb; +import io.tiledb.libtiledb.tiledb_range_t; + +public class NDRectangle implements AutoCloseable { + private SWIGTYPE_p_tiledb_ndrectangle_t ndrectanglep; + private SWIGTYPE_p_p_tiledb_ndrectangle_t ndrectanglepp; + private Context ctx; + private Domain domain; + + public NDRectangle(Context ctx, Domain domain) throws TileDBError { + this.ctx = ctx; + this.domain = domain; + ndrectanglepp = tiledb.new_tiledb_ndrectangle_tpp(); + try { + ctx.handleError( + tiledb.tiledb_ndrectangle_alloc(ctx.getCtxp(), domain.getDomainp(), ndrectanglepp)); + } catch (TileDBError err) { + tiledb.delete_tiledb_ndrectangle_tpp(ndrectanglepp); + throw err; + } + ndrectanglep = tiledb.tiledb_ndrectangle_tpp_value(ndrectanglepp); + } + + public SWIGTYPE_p_tiledb_ndrectangle_t getndrectanglep() { + return ndrectanglep; + } + + public void set_range(long dim_idx, tiledb_range_t range) {} + + @Override + public void close() throws Exception { + if (ndrectanglep != null && ndrectanglepp != null) { + tiledb.tiledb_ndrectangle_free(ndrectanglepp); + tiledb.delete_tiledb_ndrectangle_tpp(ndrectanglepp); + ndrectanglep = null; + ndrectanglepp = null; + } + } +} diff --git a/src/main/java/io/tiledb/java/api/Range.java b/src/main/java/io/tiledb/java/api/Range.java new file mode 100644 index 00000000..a180adb4 --- /dev/null +++ b/src/main/java/io/tiledb/java/api/Range.java @@ -0,0 +1,61 @@ +package io.tiledb.java.api; + +import io.tiledb.libtiledb.SWIGTYPE_p_p_tiledb_range_t; +import io.tiledb.libtiledb.tiledb; +import io.tiledb.libtiledb.tiledb_range_t; + +public class Range { + private SWIGTYPE_p_p_tiledb_range_t rangepp; + protected boolean swigCMemOwn; + private tiledb_range_t range; + + private long swigCPtr; + private Domain domain; + private Context ctx; + + public Range(Context cxt, Domain domain) throws TileDBError { + this.domain = domain; + this.ctx = cxt; + this.rangepp = tiledb.new_tiledb_range_tpp(); + this.swigCPtr = SWIGTYPE_p_p_tiledb_range_t.getCPtr(rangepp); + this.range = new tiledb_range_t(swigCPtr, true); + } + + public void setMin(long dimIdx, Object min) throws TileDBError { + Datatype dimType; + + dimType = domain.getDimension(dimIdx).getType(); + + // We use java type check here because we can not tell the difference between unsigned and + // signed + // values coming from java, i.e. A UINT16 and INT32 are both Integer classes in java. + Types.javaTypeCheck(min.getClass(), dimType.javaClass()); + + try (NativeArray minArr = new NativeArray(ctx, 1, dimType)) { + minArr.setItem(0, min); + + range.setMin(minArr.toVoidPointer()); + // range.setMin_size(BigInteger.valueOf(dimType.getNativeSize())); + + } + } + + public void setMax(long dimIdx, Object max) throws TileDBError { + Datatype dimType; + + dimType = domain.getDimension(dimIdx).getType(); + + // We use java type check here because we can not tell the difference between unsigned and + // signed + // values coming from java, i.e. A UINT16 and INT32 are both Integer classes in java. + Types.javaTypeCheck(max.getClass(), dimType.javaClass()); + + try (NativeArray minArr = new NativeArray(ctx, 1, dimType)) { + minArr.setItem(0, max); + + range.setMin(minArr.toVoidPointer()); + // range.setMin_size(BigInteger.valueOf(dimType.getNativeSize())); + + } + } +} diff --git a/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_current_domain_t.java b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_current_domain_t.java new file mode 100644 index 00000000..d5646cdc --- /dev/null +++ b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_current_domain_t.java @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.1.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package io.tiledb.libtiledb; + +public class SWIGTYPE_p_p_tiledb_current_domain_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_p_tiledb_current_domain_t( + long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_p_tiledb_current_domain_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_p_tiledb_current_domain_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_p_tiledb_current_domain_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_ndrectangle_t.java b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_ndrectangle_t.java new file mode 100644 index 00000000..6bb63fd8 --- /dev/null +++ b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_ndrectangle_t.java @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.1.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package io.tiledb.libtiledb; + +public class SWIGTYPE_p_p_tiledb_ndrectangle_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_p_tiledb_ndrectangle_t( + long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_p_tiledb_ndrectangle_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_p_tiledb_ndrectangle_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_p_tiledb_ndrectangle_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_range_t.java b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_range_t.java new file mode 100644 index 00000000..97c9ad19 --- /dev/null +++ b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_p_tiledb_range_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.1.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package io.tiledb.libtiledb; + +public class SWIGTYPE_p_p_tiledb_range_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_p_tiledb_range_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_p_tiledb_range_t() { + swigCPtr = 0; + } + + public static long getCPtr(SWIGTYPE_p_p_tiledb_range_t obj) { // todo + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_p_tiledb_range_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_current_domain_t.java b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_current_domain_t.java new file mode 100644 index 00000000..8166d797 --- /dev/null +++ b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_current_domain_t.java @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.1.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package io.tiledb.libtiledb; + +public class SWIGTYPE_p_tiledb_current_domain_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_tiledb_current_domain_t( + long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_tiledb_current_domain_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_tiledb_current_domain_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_tiledb_current_domain_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_current_domain_type_t.java b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_current_domain_type_t.java new file mode 100644 index 00000000..c60dbd6a --- /dev/null +++ b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_current_domain_type_t.java @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.1.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package io.tiledb.libtiledb; + +public class SWIGTYPE_p_tiledb_current_domain_type_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_tiledb_current_domain_type_t( + long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_tiledb_current_domain_type_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_tiledb_current_domain_type_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_tiledb_current_domain_type_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_ndrectangle_t.java b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_ndrectangle_t.java new file mode 100644 index 00000000..81bc777b --- /dev/null +++ b/src/main/java/io/tiledb/libtiledb/SWIGTYPE_p_tiledb_ndrectangle_t.java @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.1.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package io.tiledb.libtiledb; + +public class SWIGTYPE_p_tiledb_ndrectangle_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_tiledb_ndrectangle_t( + long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_tiledb_ndrectangle_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_tiledb_ndrectangle_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_tiledb_ndrectangle_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/src/main/java/io/tiledb/libtiledb/tiledb.java b/src/main/java/io/tiledb/libtiledb/tiledb.java index 6107df5b..c2749837 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledb.java +++ b/src/main/java/io/tiledb/libtiledb/tiledb.java @@ -631,6 +631,36 @@ public static tiledb_field_origin_t tiledb_field_origin_tp_value( tiledbJNI.tiledb_field_origin_tp_value(SWIGTYPE_p_tiledb_field_origin_t.getCPtr(obj))); } + public static SWIGTYPE_p_tiledb_current_domain_type_t new_tiledb_current_domain_type_tp() { + long cPtr = tiledbJNI.new_tiledb_current_domain_type_tp(); + return (cPtr == 0) ? null : new SWIGTYPE_p_tiledb_current_domain_type_t(cPtr, false); + } + + public static SWIGTYPE_p_tiledb_current_domain_type_t copy_tiledb_current_domain_type_tp( + tiledb_current_domain_type_t value) { + long cPtr = tiledbJNI.copy_tiledb_current_domain_type_tp(value.swigValue()); + return (cPtr == 0) ? null : new SWIGTYPE_p_tiledb_current_domain_type_t(cPtr, false); + } + + public static void delete_tiledb_current_domain_type_tp( + SWIGTYPE_p_tiledb_current_domain_type_t obj) { + tiledbJNI.delete_tiledb_current_domain_type_tp( + SWIGTYPE_p_tiledb_current_domain_type_t.getCPtr(obj)); + } + + public static void tiledb_current_domain_type_tp_assign( + SWIGTYPE_p_tiledb_current_domain_type_t obj, tiledb_current_domain_type_t value) { + tiledbJNI.tiledb_current_domain_type_tp_assign( + SWIGTYPE_p_tiledb_current_domain_type_t.getCPtr(obj), value.swigValue()); + } + + public static tiledb_current_domain_type_t tiledb_current_domain_type_tp_value( + SWIGTYPE_p_tiledb_current_domain_type_t obj) { + return tiledb_current_domain_type_t.swigToEnum( + tiledbJNI.tiledb_current_domain_type_tp_value( + SWIGTYPE_p_tiledb_current_domain_type_t.getCPtr(obj))); + } + public static SWIGTYPE_p_p_tiledb_array_t new_tiledb_array_tpp() { long cPtr = tiledbJNI.new_tiledb_array_tpp(); return (cPtr == 0) ? null : new SWIGTYPE_p_p_tiledb_array_t(cPtr, false); @@ -1417,6 +1447,92 @@ public static SWIGTYPE_p_tiledb_query_channel_t tiledb_query_channel_tpp_value( return (cPtr == 0) ? null : new SWIGTYPE_p_tiledb_query_channel_t(cPtr, false); } + public static SWIGTYPE_p_p_tiledb_ndrectangle_t new_tiledb_ndrectangle_tpp() { + long cPtr = tiledbJNI.new_tiledb_ndrectangle_tpp(); + return (cPtr == 0) ? null : new SWIGTYPE_p_p_tiledb_ndrectangle_t(cPtr, false); + } + + public static SWIGTYPE_p_p_tiledb_ndrectangle_t copy_tiledb_ndrectangle_tpp( + SWIGTYPE_p_tiledb_ndrectangle_t value) { + long cPtr = + tiledbJNI.copy_tiledb_ndrectangle_tpp(SWIGTYPE_p_tiledb_ndrectangle_t.getCPtr(value)); + return (cPtr == 0) ? null : new SWIGTYPE_p_p_tiledb_ndrectangle_t(cPtr, false); + } + + public static void delete_tiledb_ndrectangle_tpp(SWIGTYPE_p_p_tiledb_ndrectangle_t obj) { + tiledbJNI.delete_tiledb_ndrectangle_tpp(SWIGTYPE_p_p_tiledb_ndrectangle_t.getCPtr(obj)); + } + + public static void tiledb_ndrectangle_tpp_assign( + SWIGTYPE_p_p_tiledb_ndrectangle_t obj, SWIGTYPE_p_tiledb_ndrectangle_t value) { + tiledbJNI.tiledb_ndrectangle_tpp_assign( + SWIGTYPE_p_p_tiledb_ndrectangle_t.getCPtr(obj), + SWIGTYPE_p_tiledb_ndrectangle_t.getCPtr(value)); + } + + public static SWIGTYPE_p_tiledb_ndrectangle_t tiledb_ndrectangle_tpp_value( + SWIGTYPE_p_p_tiledb_ndrectangle_t obj) { + long cPtr = + tiledbJNI.tiledb_ndrectangle_tpp_value(SWIGTYPE_p_p_tiledb_ndrectangle_t.getCPtr(obj)); + return (cPtr == 0) ? null : new SWIGTYPE_p_tiledb_ndrectangle_t(cPtr, false); + } + + public static SWIGTYPE_p_p_tiledb_current_domain_t new_tiledb_current_domain_tpp() { + long cPtr = tiledbJNI.new_tiledb_current_domain_tpp(); + return (cPtr == 0) ? null : new SWIGTYPE_p_p_tiledb_current_domain_t(cPtr, false); + } + + public static SWIGTYPE_p_p_tiledb_current_domain_t copy_tiledb_current_domain_tpp( + SWIGTYPE_p_tiledb_current_domain_t value) { + long cPtr = + tiledbJNI.copy_tiledb_current_domain_tpp(SWIGTYPE_p_tiledb_current_domain_t.getCPtr(value)); + return (cPtr == 0) ? null : new SWIGTYPE_p_p_tiledb_current_domain_t(cPtr, false); + } + + public static void delete_tiledb_current_domain_tpp(SWIGTYPE_p_p_tiledb_current_domain_t obj) { + tiledbJNI.delete_tiledb_current_domain_tpp(SWIGTYPE_p_p_tiledb_current_domain_t.getCPtr(obj)); + } + + public static void tiledb_current_domain_tpp_assign( + SWIGTYPE_p_p_tiledb_current_domain_t obj, SWIGTYPE_p_tiledb_current_domain_t value) { + tiledbJNI.tiledb_current_domain_tpp_assign( + SWIGTYPE_p_p_tiledb_current_domain_t.getCPtr(obj), + SWIGTYPE_p_tiledb_current_domain_t.getCPtr(value)); + } + + public static SWIGTYPE_p_tiledb_current_domain_t tiledb_current_domain_tpp_value( + SWIGTYPE_p_p_tiledb_current_domain_t obj) { + long cPtr = + tiledbJNI.tiledb_current_domain_tpp_value( + SWIGTYPE_p_p_tiledb_current_domain_t.getCPtr(obj)); + return (cPtr == 0) ? null : new SWIGTYPE_p_tiledb_current_domain_t(cPtr, false); + } + + public static SWIGTYPE_p_p_tiledb_range_t new_tiledb_range_tpp() { + long cPtr = tiledbJNI.new_tiledb_range_tpp(); + return (cPtr == 0) ? null : new SWIGTYPE_p_p_tiledb_range_t(cPtr, false); + } + + public static SWIGTYPE_p_p_tiledb_range_t copy_tiledb_range_tpp(tiledb_range_t value) { + long cPtr = tiledbJNI.copy_tiledb_range_tpp(tiledb_range_t.getCPtr(value), value); + return (cPtr == 0) ? null : new SWIGTYPE_p_p_tiledb_range_t(cPtr, false); + } + + public static void delete_tiledb_range_tpp(SWIGTYPE_p_p_tiledb_range_t obj) { + tiledbJNI.delete_tiledb_range_tpp(SWIGTYPE_p_p_tiledb_range_t.getCPtr(obj)); + } + + public static void tiledb_range_tpp_assign( + SWIGTYPE_p_p_tiledb_range_t obj, tiledb_range_t value) { + tiledbJNI.tiledb_range_tpp_assign( + SWIGTYPE_p_p_tiledb_range_t.getCPtr(obj), tiledb_range_t.getCPtr(value), value); + } + + public static tiledb_range_t tiledb_range_tpp_value(SWIGTYPE_p_p_tiledb_range_t obj) { + long cPtr = tiledbJNI.tiledb_range_tpp_value(SWIGTYPE_p_p_tiledb_range_t.getCPtr(obj)); + return (cPtr == 0) ? null : new tiledb_range_t(cPtr, false); + } + public static int sizeOfInt32() { return tiledbJNI.sizeOfInt32(); } @@ -5167,6 +5283,137 @@ public static capi_return_t tiledb_attribute_get_enumeration_name( true); } + public static capi_return_t tiledb_ndrectangle_alloc( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_domain_t domain, + SWIGTYPE_p_p_tiledb_ndrectangle_t ndr) { + return new capi_return_t( + tiledbJNI.tiledb_ndrectangle_alloc( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_domain_t.getCPtr(domain), + SWIGTYPE_p_p_tiledb_ndrectangle_t.getCPtr(ndr)), + true); + } + + public static capi_return_t tiledb_ndrectangle_free(SWIGTYPE_p_p_tiledb_ndrectangle_t ndr) { + return new capi_return_t( + tiledbJNI.tiledb_ndrectangle_free(SWIGTYPE_p_p_tiledb_ndrectangle_t.getCPtr(ndr)), true); + } + + public static capi_return_t tiledb_ndrectangle_get_range_from_name( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_ndrectangle_t ndr, + String name, + tiledb_range_t range) { + return new capi_return_t( + tiledbJNI.tiledb_ndrectangle_get_range_from_name( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_ndrectangle_t.getCPtr(ndr), + name, + tiledb_range_t.getCPtr(range), + range), + true); + } + + public static capi_return_t tiledb_ndrectangle_get_range( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_ndrectangle_t ndr, + long idx, + tiledb_range_t range) { + return new capi_return_t( + tiledbJNI.tiledb_ndrectangle_get_range( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_ndrectangle_t.getCPtr(ndr), + idx, + tiledb_range_t.getCPtr(range), + range), + true); + } + + public static capi_return_t tiledb_ndrectangle_set_range_for_name( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_ndrectangle_t ndr, + String name, + tiledb_range_t range) { + return new capi_return_t( + tiledbJNI.tiledb_ndrectangle_set_range_for_name( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_ndrectangle_t.getCPtr(ndr), + name, + tiledb_range_t.getCPtr(range), + range), + true); + } + + public static capi_return_t tiledb_ndrectangle_set_range( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_ndrectangle_t ndr, + long idx, + tiledb_range_t range) { + return new capi_return_t( + tiledbJNI.tiledb_ndrectangle_set_range( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_ndrectangle_t.getCPtr(ndr), + idx, + tiledb_range_t.getCPtr(range), + range), + true); + } + + public static capi_return_t tiledb_current_domain_create( + SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_p_tiledb_current_domain_t current_domain) { + return new capi_return_t( + tiledbJNI.tiledb_current_domain_create( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_p_tiledb_current_domain_t.getCPtr(current_domain)), + true); + } + + public static capi_return_t tiledb_current_domain_free( + SWIGTYPE_p_p_tiledb_current_domain_t current_domain) { + return new capi_return_t( + tiledbJNI.tiledb_current_domain_free( + SWIGTYPE_p_p_tiledb_current_domain_t.getCPtr(current_domain)), + true); + } + + public static capi_return_t tiledb_current_domain_set_ndrectangle( + SWIGTYPE_p_tiledb_current_domain_t current_domain, SWIGTYPE_p_tiledb_ndrectangle_t ndr) { + return new capi_return_t( + tiledbJNI.tiledb_current_domain_set_ndrectangle( + SWIGTYPE_p_tiledb_current_domain_t.getCPtr(current_domain), + SWIGTYPE_p_tiledb_ndrectangle_t.getCPtr(ndr)), + true); + } + + public static capi_return_t tiledb_current_domain_get_ndrectangle( + SWIGTYPE_p_tiledb_current_domain_t current_domain, SWIGTYPE_p_p_tiledb_ndrectangle_t ndr) { + return new capi_return_t( + tiledbJNI.tiledb_current_domain_get_ndrectangle( + SWIGTYPE_p_tiledb_current_domain_t.getCPtr(current_domain), + SWIGTYPE_p_p_tiledb_ndrectangle_t.getCPtr(ndr)), + true); + } + + public static capi_return_t tiledb_current_domain_get_is_empty( + SWIGTYPE_p_tiledb_current_domain_t current_domain, SWIGTYPE_p_unsigned_int is_empty) { + return new capi_return_t( + tiledbJNI.tiledb_current_domain_get_is_empty( + SWIGTYPE_p_tiledb_current_domain_t.getCPtr(current_domain), + SWIGTYPE_p_unsigned_int.getCPtr(is_empty)), + true); + } + + public static capi_return_t tiledb_current_domain_get_type( + SWIGTYPE_p_tiledb_current_domain_t current_domain, + SWIGTYPE_p_tiledb_current_domain_type_t type) { + return new capi_return_t( + tiledbJNI.tiledb_current_domain_get_type( + SWIGTYPE_p_tiledb_current_domain_t.getCPtr(current_domain), + SWIGTYPE_p_tiledb_current_domain_type_t.getCPtr(type)), + true); + } + public static capi_return_t tiledb_enumeration_alloc( SWIGTYPE_p_tiledb_ctx_t ctx, String name, @@ -5913,6 +6160,18 @@ public static int tiledb_array_schema_evolution_set_timestamp_range( hi); } + public static capi_return_t tiledb_array_schema_evolution_expand_current_domain( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_schema_evolution_t array_schema_evolution, + SWIGTYPE_p_tiledb_current_domain_t expanded_domain) { + return new capi_return_t( + tiledbJNI.tiledb_array_schema_evolution_expand_current_domain( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_schema_evolution_t.getCPtr(array_schema_evolution), + SWIGTYPE_p_tiledb_current_domain_t.getCPtr(expanded_domain)), + true); + } + public static int tiledb_array_schema_timestamp_range( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_array_schema_t array_schema, @@ -5935,6 +6194,26 @@ public static int tiledb_array_schema_add_enumeration( SWIGTYPE_p_tiledb_enumeration_t.getCPtr(enumeration)); } + public static int tiledb_array_schema_set_current_domain( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_schema_t array_schema, + SWIGTYPE_p_tiledb_current_domain_t current_domain) { + return tiledbJNI.tiledb_array_schema_set_current_domain( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_schema_t.getCPtr(array_schema), + SWIGTYPE_p_tiledb_current_domain_t.getCPtr(current_domain)); + } + + public static int tiledb_array_schema_get_current_domain( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_array_schema_t array_schema, + SWIGTYPE_p_p_tiledb_current_domain_t current_domain) { + return tiledbJNI.tiledb_array_schema_get_current_domain( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_array_schema_t.getCPtr(array_schema), + SWIGTYPE_p_p_tiledb_current_domain_t.getCPtr(current_domain)); + } + public static int tiledb_array_evolve( SWIGTYPE_p_tiledb_ctx_t ctx, String array_uri, diff --git a/src/main/java/io/tiledb/libtiledb/tiledbConstants.java b/src/main/java/io/tiledb/libtiledb/tiledbConstants.java index 99d47fa5..81e4dffb 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledbConstants.java +++ b/src/main/java/io/tiledb/libtiledb/tiledbConstants.java @@ -16,6 +16,6 @@ public interface tiledbConstants { public static final int TILEDB_OK = (0); public static final int TILEDB_OOM = (-2); public static final int TILEDB_VERSION_MAJOR = 2; - public static final int TILEDB_VERSION_MINOR = 24; + public static final int TILEDB_VERSION_MINOR = 25; 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 0ffa4e97..4fd4e5cc 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledbJNI.java +++ b/src/main/java/io/tiledb/libtiledb/tiledbJNI.java @@ -461,6 +461,16 @@ public static final native void uint64_tArray_setitem( public static final native int tiledb_field_origin_tp_value(long jarg1); + public static final native long new_tiledb_current_domain_type_tp(); + + public static final native long copy_tiledb_current_domain_type_tp(int jarg1); + + public static final native void delete_tiledb_current_domain_type_tp(long jarg1); + + public static final native void tiledb_current_domain_type_tp_assign(long jarg1, int jarg2); + + public static final native int tiledb_current_domain_type_tp_value(long jarg1); + public static final native long new_tiledb_array_tpp(); public static final native long copy_tiledb_array_tpp(long jarg1); @@ -732,6 +742,37 @@ public static final native void capi_return_tpp_assign( public static final native long tiledb_query_channel_tpp_value(long jarg1); + public static final native long new_tiledb_ndrectangle_tpp(); + + public static final native long copy_tiledb_ndrectangle_tpp(long jarg1); + + public static final native void delete_tiledb_ndrectangle_tpp(long jarg1); + + public static final native void tiledb_ndrectangle_tpp_assign(long jarg1, long jarg2); + + public static final native long tiledb_ndrectangle_tpp_value(long jarg1); + + public static final native long new_tiledb_current_domain_tpp(); + + public static final native long copy_tiledb_current_domain_tpp(long jarg1); + + public static final native void delete_tiledb_current_domain_tpp(long jarg1); + + public static final native void tiledb_current_domain_tpp_assign(long jarg1, long jarg2); + + public static final native long tiledb_current_domain_tpp_value(long jarg1); + + public static final native long new_tiledb_range_tpp(); + + public static final native long copy_tiledb_range_tpp(long jarg1, tiledb_range_t jarg1_); + + public static final native void delete_tiledb_range_tpp(long jarg1); + + public static final native void tiledb_range_tpp_assign( + long jarg1, long jarg2, tiledb_range_t jarg2_); + + public static final native long tiledb_range_tpp_value(long jarg1); + public static final native int sizeOfInt32(); public static final native int sizeOfInt64(); @@ -1707,6 +1748,60 @@ public static final native long tiledb_attribute_set_enumeration_name( public static final native long tiledb_attribute_get_enumeration_name( long jarg1, long jarg2, long jarg3); + public static final native void tiledb_range_t_min_set( + long jarg1, tiledb_range_t jarg1_, long jarg2); + + public static final native long tiledb_range_t_min_get(long jarg1, tiledb_range_t jarg1_); + + public static final native void tiledb_range_t_min_size_set( + long jarg1, tiledb_range_t jarg1_, java.math.BigInteger jarg2); + + public static final native java.math.BigInteger tiledb_range_t_min_size_get( + long jarg1, tiledb_range_t jarg1_); + + public static final native void tiledb_range_t_max_set( + long jarg1, tiledb_range_t jarg1_, long jarg2); + + public static final native long tiledb_range_t_max_get(long jarg1, tiledb_range_t jarg1_); + + public static final native void tiledb_range_t_max_size_set( + long jarg1, tiledb_range_t jarg1_, java.math.BigInteger jarg2); + + public static final native java.math.BigInteger tiledb_range_t_max_size_get( + long jarg1, tiledb_range_t jarg1_); + + public static final native long new_tiledb_range_t(); + + public static final native void delete_tiledb_range_t(long jarg1); + + public static final native long tiledb_ndrectangle_alloc(long jarg1, long jarg2, long jarg3); + + public static final native long tiledb_ndrectangle_free(long jarg1); + + public static final native long tiledb_ndrectangle_get_range_from_name( + long jarg1, long jarg2, String jarg3, long jarg4, tiledb_range_t jarg4_); + + public static final native long tiledb_ndrectangle_get_range( + long jarg1, long jarg2, long jarg3, long jarg4, tiledb_range_t jarg4_); + + public static final native long tiledb_ndrectangle_set_range_for_name( + long jarg1, long jarg2, String jarg3, long jarg4, tiledb_range_t jarg4_); + + public static final native long tiledb_ndrectangle_set_range( + long jarg1, long jarg2, long jarg3, long jarg4, tiledb_range_t jarg4_); + + public static final native long tiledb_current_domain_create(long jarg1, long jarg2); + + public static final native long tiledb_current_domain_free(long jarg1); + + public static final native long tiledb_current_domain_set_ndrectangle(long jarg1, long jarg2); + + public static final native long tiledb_current_domain_get_ndrectangle(long jarg1, long jarg2); + + public static final native long tiledb_current_domain_get_is_empty(long jarg1, long jarg2); + + public static final native long tiledb_current_domain_get_type(long jarg1, long jarg2); + public static final native long tiledb_enumeration_alloc( long jarg1, String jarg2, @@ -1897,12 +1992,21 @@ public static final native long tiledb_array_schema_evolution_drop_enumeration( public static final native int tiledb_array_schema_evolution_set_timestamp_range( long jarg1, long jarg2, java.math.BigInteger jarg3, java.math.BigInteger jarg4); + public static final native long tiledb_array_schema_evolution_expand_current_domain( + long jarg1, long jarg2, long jarg3); + public static final native int tiledb_array_schema_timestamp_range( long jarg1, long jarg2, long jarg3, long jarg4); public static final native int tiledb_array_schema_add_enumeration( long jarg1, long jarg2, long jarg3); + public static final native int tiledb_array_schema_set_current_domain( + long jarg1, long jarg2, long jarg3); + + public static final native int tiledb_array_schema_get_current_domain( + long jarg1, long jarg2, long jarg3); + public static final native int tiledb_array_evolve(long jarg1, String jarg2, long jarg3); public static final native long tiledb_array_get_enumeration( diff --git a/src/main/java/io/tiledb/libtiledb/tiledb_current_domain_type_t.java b/src/main/java/io/tiledb/libtiledb/tiledb_current_domain_type_t.java new file mode 100644 index 00000000..b98c0424 --- /dev/null +++ b/src/main/java/io/tiledb/libtiledb/tiledb_current_domain_type_t.java @@ -0,0 +1,52 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.1.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package io.tiledb.libtiledb; + +public enum tiledb_current_domain_type_t { + TILEDB_NDRECTANGLE(0); + + public final int swigValue() { + return swigValue; + } + + public static tiledb_current_domain_type_t swigToEnum(int swigValue) { + tiledb_current_domain_type_t[] swigValues = + tiledb_current_domain_type_t.class.getEnumConstants(); + if (swigValue < swigValues.length + && swigValue >= 0 + && swigValues[swigValue].swigValue == swigValue) return swigValues[swigValue]; + for (tiledb_current_domain_type_t swigEnum : swigValues) + if (swigEnum.swigValue == swigValue) return swigEnum; + throw new IllegalArgumentException( + "No enum " + tiledb_current_domain_type_t.class + " with value " + swigValue); + } + + @SuppressWarnings("unused") + private tiledb_current_domain_type_t() { + this.swigValue = SwigNext.next++; + } + + @SuppressWarnings("unused") + private tiledb_current_domain_type_t(int swigValue) { + this.swigValue = swigValue; + SwigNext.next = swigValue + 1; + } + + @SuppressWarnings("unused") + private tiledb_current_domain_type_t(tiledb_current_domain_type_t swigEnum) { + this.swigValue = swigEnum.swigValue; + SwigNext.next = this.swigValue + 1; + } + + private final int swigValue; + + private static class SwigNext { + private static int next = 0; + } +} diff --git a/src/main/java/io/tiledb/libtiledb/tiledb_range_t.java b/src/main/java/io/tiledb/libtiledb/tiledb_range_t.java new file mode 100644 index 00000000..ed940bfb --- /dev/null +++ b/src/main/java/io/tiledb/libtiledb/tiledb_range_t.java @@ -0,0 +1,88 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.1.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package io.tiledb.libtiledb; + +public class tiledb_range_t { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + public tiledb_range_t(long cPtr, boolean cMemoryOwn) { // todo + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(tiledb_range_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(tiledb_range_t obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings("deprecation") + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + tiledbJNI.delete_tiledb_range_t(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setMin(SWIGTYPE_p_void value) { + tiledbJNI.tiledb_range_t_min_set(swigCPtr, this, SWIGTYPE_p_void.getCPtr(value)); + } + + public SWIGTYPE_p_void getMin() { + long cPtr = tiledbJNI.tiledb_range_t_min_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_void(cPtr, false); + } + + public void setMin_size(java.math.BigInteger value) { + tiledbJNI.tiledb_range_t_min_size_set(swigCPtr, this, value); + } + + public java.math.BigInteger getMin_size() { + return tiledbJNI.tiledb_range_t_min_size_get(swigCPtr, this); + } + + public void setMax(SWIGTYPE_p_void value) { + tiledbJNI.tiledb_range_t_max_set(swigCPtr, this, SWIGTYPE_p_void.getCPtr(value)); + } + + public SWIGTYPE_p_void getMax() { + long cPtr = tiledbJNI.tiledb_range_t_max_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_void(cPtr, false); + } + + public void setMax_size(java.math.BigInteger value) { + tiledbJNI.tiledb_range_t_max_size_set(swigCPtr, this, value); + } + + public java.math.BigInteger getMax_size() { + return tiledbJNI.tiledb_range_t_max_size_get(swigCPtr, this); + } + + public tiledb_range_t() { + this(tiledbJNI.new_tiledb_range_t(), true); + } +} diff --git a/src/test/java/io/tiledb/java/api/CurrentDomainTest.java b/src/test/java/io/tiledb/java/api/CurrentDomainTest.java new file mode 100644 index 00000000..3d784470 --- /dev/null +++ b/src/test/java/io/tiledb/java/api/CurrentDomainTest.java @@ -0,0 +1,21 @@ +package io.tiledb.java.api; + +import org.junit.Test; + +public class CurrentDomainTest { + + @Test + public void rangeTest() throws Exception { + Config cf = new Config(); + Context ctx = new Context(); + Dimension d1 = + new Dimension(ctx, "d1", Long.class, new Pair(1l, 4l), 2l); + Domain domain = new Domain(ctx); + domain.addDimension(d1); + + Range range = new Range(ctx, domain); + range.setMin(0, 1L); + range.setMax(0, 2L); + System.out.println("a"); + } +} diff --git a/swig/tiledb.i b/swig/tiledb.i index efdcae54..5194b833 100644 --- a/swig/tiledb.i +++ b/swig/tiledb.i @@ -41,6 +41,8 @@ typedef struct tiledb_channel_operator_t tiledb_channel_operator_t; typedef struct tiledb_channel_operation_t tiledb_channel_operation_t; typedef struct tiledb_query_channel_t tiledb_query_channel_t; typedef struct tiledb_query_field_t tiledb_query_field_t; +typedef struct tiledb_ndrectangle_t tiledb_ndrectangle_t; +typedef struct tiledb_current_domain_t tiledb_current_domain_t; %{ #include @@ -123,7 +125,7 @@ typedef struct tiledb_query_field_t tiledb_query_field_t; %pointer_functions(tiledb_encryption_type_t, tiledb_encryption_type_tp); %pointer_functions(capi_status_t, capi_status_tp); %pointer_functions(tiledb_field_origin_t, tiledb_field_origin_tp); - +%pointer_functions(tiledb_current_domain_type_t, tiledb_current_domain_type_tp); %pointer_functions(tiledb_array_t*, tiledb_array_tpp); %pointer_functions(tiledb_subarray_t*, tiledb_subarray_tpp); @@ -152,6 +154,9 @@ typedef struct tiledb_query_field_t tiledb_query_field_t; %pointer_functions(tiledb_channel_operation_t*, tiledb_channel_operation_tpp); %pointer_functions(tiledb_query_field_t*, tiledb_query_field_tpp); %pointer_functions(tiledb_query_channel_t*, tiledb_query_channel_tpp); +%pointer_functions(tiledb_ndrectangle_t*, tiledb_ndrectangle_tpp); +%pointer_functions(tiledb_current_domain_t*, tiledb_current_domain_tpp); +%pointer_functions(tiledb_range_t*, tiledb_range_tpp); %native (sizeOfInt32) int sizeOfInt32(); %native (sizeOfInt64) int sizeOfInt64(); From 23bbe7cbe841abf279659216f4fce08ca55dc80c Mon Sep 17 00:00:00 2001 From: Dimitris Staratzis <33267511+DimitrisStaratzis@users.noreply.github.com> Date: Wed, 14 Aug 2024 16:06:24 +0300 Subject: [PATCH 2/4] Complete all classes --- .../java/io/tiledb/java/api/ArraySchema.java | 28 ++++ .../tiledb/java/api/ArraySchemaEvolution.java | 10 ++ .../io/tiledb/java/api/CurrentDomain.java | 116 ++++++++++++++- .../io/tiledb/java/api/CurrentDomainType.java | 26 ++++ .../java/io/tiledb/java/api/NDRectangle.java | 51 ++++++- src/main/java/io/tiledb/java/api/Range.java | 134 +++++++++++++++--- .../io/tiledb/libtiledb/PointerUtils.java | 2 +- .../io/tiledb/java/api/CurrentDomainTest.java | 21 --- .../io/tiledb/java/api/TestCurrentDomain.java | 100 +++++++++++++ 9 files changed, 435 insertions(+), 53 deletions(-) create mode 100644 src/main/java/io/tiledb/java/api/CurrentDomainType.java delete mode 100644 src/test/java/io/tiledb/java/api/CurrentDomainTest.java create mode 100644 src/test/java/io/tiledb/java/api/TestCurrentDomain.java diff --git a/src/main/java/io/tiledb/java/api/ArraySchema.java b/src/main/java/io/tiledb/java/api/ArraySchema.java index 9be9ad7c..9bad0351 100644 --- a/src/main/java/io/tiledb/java/api/ArraySchema.java +++ b/src/main/java/io/tiledb/java/api/ArraySchema.java @@ -313,6 +313,23 @@ public Domain getDomain() throws TileDBError { return new Domain(ctx, domainpp); } + /** + * @return + * @throws TileDBError + */ + public CurrentDomain getCurrentDomain() throws TileDBError { + SWIGTYPE_p_p_tiledb_current_domain_t currentDomainpp = tiledb.new_tiledb_current_domain_tpp(); + try { + ctx.handleError( + tiledb.tiledb_array_schema_get_current_domain( + ctx.getCtxp(), getSchemap(), currentDomainpp)); + } catch (TileDBError err) { + tiledb.delete_tiledb_current_domain_tpp(currentDomainpp); + throw err; + } + return new CurrentDomain(ctx, getDomain(), currentDomainpp); + } + /** * Sets the array Domain. * @@ -335,6 +352,17 @@ public void setDomain(Domain domain) throws TileDBError { domainIsSet = true; } + /** + * @param currentDomain + * @throws TileDBError + */ + public void setCurrentDomain(CurrentDomain currentDomain) throws TileDBError { + ctx.handleError( + tiledb.tiledb_array_schema_set_current_domain( + ctx.getCtxp(), getSchemap(), currentDomain.getCurrentDomainp())); + domainIsSet = true; + } + /** * Adds an Attribute to the array. * diff --git a/src/main/java/io/tiledb/java/api/ArraySchemaEvolution.java b/src/main/java/io/tiledb/java/api/ArraySchemaEvolution.java index 1f29607d..469d170d 100644 --- a/src/main/java/io/tiledb/java/api/ArraySchemaEvolution.java +++ b/src/main/java/io/tiledb/java/api/ArraySchemaEvolution.java @@ -149,6 +149,16 @@ public void dropEnumeration(String name) throws TileDBError { ctx.getCtxp(), getEvolutionp(), name)); } + /** + * @param currentDomain + * @throws TileDBError + */ + public void expandCurrentDomain(CurrentDomain currentDomain) throws TileDBError { + ctx.handleError( + tiledb.tiledb_array_schema_evolution_expand_current_domain( + ctx.getCtxp(), getEvolutionp(), currentDomain.getCurrentDomainp())); + } + /** * Extends an Enumeration during array schema evolution. * diff --git a/src/main/java/io/tiledb/java/api/CurrentDomain.java b/src/main/java/io/tiledb/java/api/CurrentDomain.java index ea0c9bc6..607f501a 100644 --- a/src/main/java/io/tiledb/java/api/CurrentDomain.java +++ b/src/main/java/io/tiledb/java/api/CurrentDomain.java @@ -1,3 +1,117 @@ package io.tiledb.java.api; -public class CurrentDomain {} +import io.tiledb.libtiledb.*; + +public class CurrentDomain implements AutoCloseable { + private Context ctx; + private Domain domain; + private SWIGTYPE_p_p_tiledb_current_domain_t currentDomainpp; + private SWIGTYPE_p_tiledb_current_domain_t currentDomainp; + + /** + * @param ctx + * @param domain + * @param currentDomainpp + */ + protected CurrentDomain( + Context ctx, Domain domain, SWIGTYPE_p_p_tiledb_current_domain_t currentDomainpp) { + this.ctx = ctx; + this.currentDomainpp = currentDomainpp; + this.currentDomainp = tiledb.tiledb_current_domain_tpp_value(currentDomainpp); + this.domain = domain; + } + + /** + * @param ctx + * @param domain + * @throws TileDBError + */ + public CurrentDomain(Context ctx, Domain domain) throws TileDBError { + SWIGTYPE_p_p_tiledb_current_domain_t _currentDomainpp = tiledb.new_tiledb_current_domain_tpp(); + try { + ctx.handleError(tiledb.tiledb_current_domain_create(ctx.getCtxp(), _currentDomainpp)); + } catch (TileDBError err) { + tiledb.delete_tiledb_current_domain_tpp(_currentDomainpp); + throw err; + } + this.ctx = ctx; + this.currentDomainp = tiledb.tiledb_current_domain_tpp_value(_currentDomainpp); + this.currentDomainpp = _currentDomainpp; + this.domain = domain; + } + + /** @return */ + protected SWIGTYPE_p_tiledb_current_domain_t getCurrentDomainp() { + return currentDomainp; + } + + /** + * @param ndRectangle + * @throws TileDBError + */ + public void setNDRectangle(NDRectangle ndRectangle) throws TileDBError { + ctx.handleError( + tiledb.tiledb_current_domain_set_ndrectangle( + currentDomainp, ndRectangle.getndrectanglep())); + } + + /** + * @return + * @throws TileDBError + */ + public CurrentDomainType getType() throws TileDBError { + SWIGTYPE_p_tiledb_current_domain_type_t typep = tiledb.new_tiledb_current_domain_type_tp(); + CurrentDomainType currentDomainType; + try { + ctx.handleError(tiledb.tiledb_current_domain_get_type(getCurrentDomainp(), typep)); + currentDomainType = + CurrentDomainType.fromSwigEnum(tiledb.tiledb_current_domain_type_tp_value(typep)); + } finally { + tiledb.delete_tiledb_current_domain_type_tp(typep); + } + return currentDomainType; + } + + /** + * @return + * @throws TileDBError + */ + public NDRectangle getNDRectangle() throws TileDBError { + NDRectangle nd; + SWIGTYPE_p_p_tiledb_ndrectangle_t ndpp = tiledb.new_tiledb_ndrectangle_tpp(); + try { + ctx.handleError(tiledb.tiledb_current_domain_get_ndrectangle(currentDomainp, ndpp)); + nd = new NDRectangle(ctx, domain, ndpp); + } catch (TileDBError err) { + tiledb.delete_tiledb_ndrectangle_tpp(ndpp); + throw err; + } + return nd; + } + + /** + * @return + * @throws TileDBError + */ + public boolean isEmpty() throws TileDBError { + boolean isEmpty; + SWIGTYPE_p_unsigned_int retp = tiledb.new_uintp(); + try { + ctx.handleError(tiledb.tiledb_current_domain_get_is_empty(currentDomainp, retp)); + isEmpty = tiledb.uintp_value(retp) != 0; + } finally { + tiledb.delete_uintp(retp); + } + return isEmpty; + } + + @Override + public void close() { + if (currentDomainp != null) { + tiledb.tiledb_current_domain_free(currentDomainpp); + tiledb.delete_tiledb_current_domain_tpp(currentDomainpp); + currentDomainpp = null; + currentDomainp = null; + } + } +} diff --git a/src/main/java/io/tiledb/java/api/CurrentDomainType.java b/src/main/java/io/tiledb/java/api/CurrentDomainType.java new file mode 100644 index 00000000..9052ed8c --- /dev/null +++ b/src/main/java/io/tiledb/java/api/CurrentDomainType.java @@ -0,0 +1,26 @@ +package io.tiledb.java.api; + +import io.tiledb.libtiledb.tiledb_current_domain_type_t; + +public enum CurrentDomainType { + TILEDB_NDRECTANGLE; + + protected tiledb_current_domain_type_t toSwigEnum() throws TileDBError { + switch (this) { + case TILEDB_NDRECTANGLE: + return tiledb_current_domain_type_t.TILEDB_NDRECTANGLE; + default: + throw new TileDBError("No such enum value" + this.name()); + } + } + + protected static CurrentDomainType fromSwigEnum(tiledb_current_domain_type_t e) + throws TileDBError { + switch (e) { + case TILEDB_NDRECTANGLE: + return TILEDB_NDRECTANGLE; + default: + throw new TileDBError("No such enum value" + e.name()); + } + } +} diff --git a/src/main/java/io/tiledb/java/api/NDRectangle.java b/src/main/java/io/tiledb/java/api/NDRectangle.java index 7747badd..2ad4d5ec 100644 --- a/src/main/java/io/tiledb/java/api/NDRectangle.java +++ b/src/main/java/io/tiledb/java/api/NDRectangle.java @@ -1,9 +1,6 @@ package io.tiledb.java.api; -import io.tiledb.libtiledb.SWIGTYPE_p_p_tiledb_ndrectangle_t; -import io.tiledb.libtiledb.SWIGTYPE_p_tiledb_ndrectangle_t; -import io.tiledb.libtiledb.tiledb; -import io.tiledb.libtiledb.tiledb_range_t; +import io.tiledb.libtiledb.*; public class NDRectangle implements AutoCloseable { private SWIGTYPE_p_tiledb_ndrectangle_t ndrectanglep; @@ -11,10 +8,15 @@ public class NDRectangle implements AutoCloseable { private Context ctx; private Domain domain; + /** + * @param ctx + * @param domain + * @throws TileDBError + */ public NDRectangle(Context ctx, Domain domain) throws TileDBError { this.ctx = ctx; this.domain = domain; - ndrectanglepp = tiledb.new_tiledb_ndrectangle_tpp(); + this.ndrectanglepp = tiledb.new_tiledb_ndrectangle_tpp(); try { ctx.handleError( tiledb.tiledb_ndrectangle_alloc(ctx.getCtxp(), domain.getDomainp(), ndrectanglepp)); @@ -25,14 +27,49 @@ public NDRectangle(Context ctx, Domain domain) throws TileDBError { ndrectanglep = tiledb.tiledb_ndrectangle_tpp_value(ndrectanglepp); } + /** + * @param ctx + * @param domain + * @param ndpp + */ + protected NDRectangle(Context ctx, Domain domain, SWIGTYPE_p_p_tiledb_ndrectangle_t ndpp) { + this.ctx = ctx; + this.ndrectanglepp = ndpp; + this.ndrectanglep = tiledb.tiledb_ndrectangle_tpp_value(ndrectanglepp); + this.domain = domain; + } + public SWIGTYPE_p_tiledb_ndrectangle_t getndrectanglep() { return ndrectanglep; } - public void set_range(long dim_idx, tiledb_range_t range) {} + /** + * @param dimIdx + * @param range + * @throws TileDBError + */ + public void setRange(long dimIdx, Range range) throws TileDBError { // todo + name + ctx.handleError( + tiledb.tiledb_ndrectangle_set_range( + ctx.getCtxp(), this.ndrectanglep, dimIdx, range.getRange_t())); + } + + /** + * @param dimIdx + * @return + * @throws TileDBError + */ + public Range getRange(long dimIdx) throws TileDBError { // todo + name + tiledb_range_t range = new tiledb_range_t(); + + ctx.handleError( + tiledb.tiledb_ndrectangle_get_range(ctx.getCtxp(), this.ndrectanglep, dimIdx, range)); + + return new Range(this.ctx, range, this.domain, dimIdx); + } @Override - public void close() throws Exception { + public void close() { if (ndrectanglep != null && ndrectanglepp != null) { tiledb.tiledb_ndrectangle_free(ndrectanglepp); tiledb.delete_tiledb_ndrectangle_tpp(ndrectanglepp); diff --git a/src/main/java/io/tiledb/java/api/Range.java b/src/main/java/io/tiledb/java/api/Range.java index a180adb4..89ee6ecb 100644 --- a/src/main/java/io/tiledb/java/api/Range.java +++ b/src/main/java/io/tiledb/java/api/Range.java @@ -1,27 +1,34 @@ package io.tiledb.java.api; -import io.tiledb.libtiledb.SWIGTYPE_p_p_tiledb_range_t; -import io.tiledb.libtiledb.tiledb; -import io.tiledb.libtiledb.tiledb_range_t; +import io.tiledb.libtiledb.*; +import java.math.BigInteger; -public class Range { - private SWIGTYPE_p_p_tiledb_range_t rangepp; - protected boolean swigCMemOwn; +public class Range implements AutoCloseable { private tiledb_range_t range; - - private long swigCPtr; private Domain domain; private Context ctx; + private Long dimIdx; + private NativeArray min, max; - public Range(Context cxt, Domain domain) throws TileDBError { + public Range(Context cxt, Domain domain, long dimIdx) { this.domain = domain; this.ctx = cxt; - this.rangepp = tiledb.new_tiledb_range_tpp(); - this.swigCPtr = SWIGTYPE_p_p_tiledb_range_t.getCPtr(rangepp); - this.range = new tiledb_range_t(swigCPtr, true); + this.range = new tiledb_range_t(); + this.dimIdx = dimIdx; + } + + public Range(Context ctx, tiledb_range_t range, Domain domain, long dimIdx) { + this.ctx = ctx; + this.range = range; + this.domain = domain; + this.dimIdx = dimIdx; } - public void setMin(long dimIdx, Object min) throws TileDBError { + /** + * @param min + * @throws TileDBError + */ + public synchronized void setMin(Object min) throws TileDBError { Datatype dimType; dimType = domain.getDimension(dimIdx).getType(); @@ -31,16 +38,37 @@ public void setMin(long dimIdx, Object min) throws TileDBError { // values coming from java, i.e. A UINT16 and INT32 are both Integer classes in java. Types.javaTypeCheck(min.getClass(), dimType.javaClass()); - try (NativeArray minArr = new NativeArray(ctx, 1, dimType)) { - minArr.setItem(0, min); + NativeArray minArr = new NativeArray(ctx, 1, dimType); + minArr.setItem(0, min); + range.setMin_size(BigInteger.valueOf(dimType.getNativeSize())); + range.setMin(minArr.toVoidPointer()); + } - range.setMin(minArr.toVoidPointer()); - // range.setMin_size(BigInteger.valueOf(dimType.getNativeSize())); + /** @param size */ + public synchronized void setMinSize(long size) { + range.setMin_size(BigInteger.valueOf(size)); + } - } + /** @param size */ + public synchronized void setMinSize(BigInteger size) { // change to bigint + range.setMin_size(size); } - public void setMax(long dimIdx, Object max) throws TileDBError { + /** @return */ + public synchronized long getMinSize() { + return range.getMin_size().longValue(); + } + + /** @return */ + public synchronized BigInteger getMinSizeBI() { + return range.getMin_size(); + } + + /** + * @param max + * @throws TileDBError + */ + public synchronized void setMax(Object max) throws TileDBError { Datatype dimType; dimType = domain.getDimension(dimIdx).getType(); @@ -50,12 +78,72 @@ public void setMax(long dimIdx, Object max) throws TileDBError { // values coming from java, i.e. A UINT16 and INT32 are both Integer classes in java. Types.javaTypeCheck(max.getClass(), dimType.javaClass()); - try (NativeArray minArr = new NativeArray(ctx, 1, dimType)) { - minArr.setItem(0, max); + NativeArray maxArr = new NativeArray(ctx, 1, dimType); + maxArr.setItem(0, max); - range.setMin(minArr.toVoidPointer()); - // range.setMin_size(BigInteger.valueOf(dimType.getNativeSize())); + range.setMax_size(BigInteger.valueOf(dimType.getNativeSize())); + range.setMax(maxArr.toVoidPointer()); + } + /** @param size */ + public synchronized void setMaxSize(long size) { + range.setMax_size(BigInteger.valueOf(size)); + } + + /** @param size */ + public synchronized void setMaxSize(BigInteger size) { + range.setMax_size(size); + } + + /** @return */ + public synchronized long getMaxSize() { + return range.getMax_size().longValue(); + } + + /** @return */ + public synchronized BigInteger getMaxSizeBI() { + return range.getMax_size(); + } + + /** + * @return + * @throws TileDBError + */ + public synchronized Object getMin() throws TileDBError { + Datatype dimType; + try (Dimension dim = domain.getDimension(dimIdx)) { + dimType = dim.getType(); + SWIGTYPE_p_void minp = range.getMin(); + Object ret; + min = new NativeArray(ctx, dimType, minp, 1); + ret = min.getItem(0); + return ret; + } + } + + /** + * @return + * @throws TileDBError + */ + public synchronized Object getMax() throws TileDBError { + Datatype dimType; + try (Dimension dim = domain.getDimension(dimIdx)) { + dimType = dim.getType(); + SWIGTYPE_p_void maxp = range.getMax(); + Object ret; + max = new NativeArray(ctx, dimType, maxp, 1); + ret = max.getItem(0); + return ret; } } + + /** @return */ + public tiledb_range_t getRange_t() { + return range; + } + + @Override + public void close() { + range.delete(); + } } diff --git a/src/main/java/io/tiledb/libtiledb/PointerUtils.java b/src/main/java/io/tiledb/libtiledb/PointerUtils.java index 3ea22a30..24a103fe 100644 --- a/src/main/java/io/tiledb/libtiledb/PointerUtils.java +++ b/src/main/java/io/tiledb/libtiledb/PointerUtils.java @@ -95,7 +95,7 @@ public static int32_tArray int32_tArrayFromVoid(SWIGTYPE_p_void p) { } public static int64_tArray int64_tArrayFromVoid(SWIGTYPE_p_void p) { - return new int64_tArray(SWIGTYPE_p_void.getCPtr(p), false); + return new int64_tArray(SWIGTYPE_p_void.getCPtr(p), true); } public static charArray charArrayFromVoid(SWIGTYPE_p_void p) { diff --git a/src/test/java/io/tiledb/java/api/CurrentDomainTest.java b/src/test/java/io/tiledb/java/api/CurrentDomainTest.java deleted file mode 100644 index 3d784470..00000000 --- a/src/test/java/io/tiledb/java/api/CurrentDomainTest.java +++ /dev/null @@ -1,21 +0,0 @@ -package io.tiledb.java.api; - -import org.junit.Test; - -public class CurrentDomainTest { - - @Test - public void rangeTest() throws Exception { - Config cf = new Config(); - Context ctx = new Context(); - Dimension d1 = - new Dimension(ctx, "d1", Long.class, new Pair(1l, 4l), 2l); - Domain domain = new Domain(ctx); - domain.addDimension(d1); - - Range range = new Range(ctx, domain); - range.setMin(0, 1L); - range.setMax(0, 2L); - System.out.println("a"); - } -} diff --git a/src/test/java/io/tiledb/java/api/TestCurrentDomain.java b/src/test/java/io/tiledb/java/api/TestCurrentDomain.java new file mode 100644 index 00000000..6870b9b1 --- /dev/null +++ b/src/test/java/io/tiledb/java/api/TestCurrentDomain.java @@ -0,0 +1,100 @@ +package io.tiledb.java.api; + +import static io.tiledb.java.api.CurrentDomainType.TILEDB_NDRECTANGLE; +import static io.tiledb.java.api.QueryType.TILEDB_READ; + +import java.nio.file.Files; +import java.nio.file.Paths; +import org.junit.*; +import org.junit.rules.TemporaryFolder; + +public class TestCurrentDomain { + + private Context ctx; + private ArraySchema schema; + private Domain domain; + private String arrayUri = "current_domain_test"; + + @Rule public TemporaryFolder temp = new TemporaryFolder(); + + @Before + public void setup() throws Exception { + ctx = new Context(); + if (Files.exists(Paths.get(arrayUri))) { + TileDBObject.remove(ctx, arrayUri); + } + schema = new ArraySchema(ctx, ArrayType.TILEDB_SPARSE); + Dimension d1 = + new Dimension(ctx, "d1", Datatype.TILEDB_INT64, new Pair(1l, 4l), 1l); + domain = new Domain(ctx); + domain.addDimension(d1); + schema.setDomain(domain); + + Range range = new Range(ctx, domain, 0); + range.setMin(1L); + range.setMax(3L); + + NDRectangle ndRectangle = new NDRectangle(ctx, domain); + ndRectangle.setRange(0, range); + + CurrentDomain currentDomain = new CurrentDomain(ctx, domain); + currentDomain.setNDRectangle(ndRectangle); + + schema.setCurrentDomain(currentDomain); + + Array.create(arrayUri, schema); + + range.close(); + ndRectangle.close(); + currentDomain.close(); + } + + @After + public void tearDown() throws Exception { + if (Files.exists(Paths.get(arrayUri))) { + TileDBObject.remove(ctx, arrayUri); + } + ctx.close(); + } + + @Test + public void currentDomainTest() throws TileDBError { + // Create range and test values + Array array = new Array(ctx, arrayUri, TILEDB_READ); + ArraySchema schema = array.getSchema(); + + CurrentDomain cd = schema.getCurrentDomain(); + Assert.assertFalse(cd.isEmpty()); + + Assert.assertEquals(TILEDB_NDRECTANGLE, cd.getType()); + + NDRectangle nd = cd.getNDRectangle(); + Range range = nd.getRange(0); + + Assert.assertEquals(8, range.getMinSize()); + Assert.assertEquals(1L, (long) range.getMin()); + + Assert.assertEquals(8, range.getMaxSize()); + Assert.assertEquals(3L, (long) range.getMax()); + range.close(); + + // Evolution test + ArraySchemaEvolution schemaEvolution = new ArraySchemaEvolution(ctx); + Range newRange = new Range(ctx, domain, 0); + newRange.setMin(1L); + newRange.setMax(4L); + CurrentDomain newCurrentDomain = new CurrentDomain(ctx, domain); + NDRectangle newND = new NDRectangle(ctx, domain); + newND.setRange(0, newRange); + newCurrentDomain.setNDRectangle(newND); + schemaEvolution.expandCurrentDomain(newCurrentDomain); + schemaEvolution.evolveArray(arrayUri); + + // clean up + newRange.close(); + array.close(); + schemaEvolution.close(); + newND.close(); + newCurrentDomain.close(); + } +} From bb4865f839b8ad8c39a4d1f45653894e38dd5431 Mon Sep 17 00:00:00 2001 From: Dimitris Staratzis <33267511+DimitrisStaratzis@users.noreply.github.com> Date: Thu, 15 Aug 2024 14:49:03 +0300 Subject: [PATCH 3/4] add support for var dims and complete javadoc --- .../java/io/tiledb/java/api/ArraySchema.java | 9 +- .../tiledb/java/api/ArraySchemaEvolution.java | 6 +- .../io/tiledb/java/api/CurrentDomain.java | 37 ++++-- .../java/io/tiledb/java/api/NDRectangle.java | 35 +++-- src/main/java/io/tiledb/java/api/Range.java | 123 +++++++++++++++--- .../io/tiledb/java/api/TestCurrentDomain.java | 43 ++++++ 6 files changed, 211 insertions(+), 42 deletions(-) diff --git a/src/main/java/io/tiledb/java/api/ArraySchema.java b/src/main/java/io/tiledb/java/api/ArraySchema.java index 9bad0351..db402523 100644 --- a/src/main/java/io/tiledb/java/api/ArraySchema.java +++ b/src/main/java/io/tiledb/java/api/ArraySchema.java @@ -314,7 +314,10 @@ public Domain getDomain() throws TileDBError { } /** - * @return + * Returns a copy of the schema's array currentDomain. To change the currentDomain, use + * `set_current_domain()` + * + * @return The current domain * @throws TileDBError */ public CurrentDomain getCurrentDomain() throws TileDBError { @@ -353,7 +356,9 @@ public void setDomain(Domain domain) throws TileDBError { } /** - * @param currentDomain + * Sets the currentDomain. + * + * @param currentDomain The current domain to set * @throws TileDBError */ public void setCurrentDomain(CurrentDomain currentDomain) throws TileDBError { diff --git a/src/main/java/io/tiledb/java/api/ArraySchemaEvolution.java b/src/main/java/io/tiledb/java/api/ArraySchemaEvolution.java index 469d170d..9d9abf61 100644 --- a/src/main/java/io/tiledb/java/api/ArraySchemaEvolution.java +++ b/src/main/java/io/tiledb/java/api/ArraySchemaEvolution.java @@ -150,7 +150,11 @@ public void dropEnumeration(String name) throws TileDBError { } /** - * @param currentDomain + * Expands the current domain during array schema evolution. TileDB will enforce that the new + * current domain is expanding on the current one and not contracting during + * `tiledb_array_evolve`. + * + * @param currentDomain The current domain we want to expand the schema to * @throws TileDBError */ public void expandCurrentDomain(CurrentDomain currentDomain) throws TileDBError { diff --git a/src/main/java/io/tiledb/java/api/CurrentDomain.java b/src/main/java/io/tiledb/java/api/CurrentDomain.java index 607f501a..c381473c 100644 --- a/src/main/java/io/tiledb/java/api/CurrentDomain.java +++ b/src/main/java/io/tiledb/java/api/CurrentDomain.java @@ -9,9 +9,11 @@ public class CurrentDomain implements AutoCloseable { private SWIGTYPE_p_tiledb_current_domain_t currentDomainp; /** - * @param ctx - * @param domain - * @param currentDomainpp + * Constructor + * + * @param ctx The context + * @param domain The array domain + * @param currentDomainpp The current domain c pointer */ protected CurrentDomain( Context ctx, Domain domain, SWIGTYPE_p_p_tiledb_current_domain_t currentDomainpp) { @@ -22,8 +24,10 @@ protected CurrentDomain( } /** - * @param ctx - * @param domain + * Constructor + * + * @param ctx The context + * @param domain The array domain * @throws TileDBError */ public CurrentDomain(Context ctx, Domain domain) throws TileDBError { @@ -40,13 +44,19 @@ public CurrentDomain(Context ctx, Domain domain) throws TileDBError { this.domain = domain; } - /** @return */ + /** + * Returns the c pointer for this current domain object + * + * @return + */ protected SWIGTYPE_p_tiledb_current_domain_t getCurrentDomainp() { return currentDomainp; } /** - * @param ndRectangle + * Set a N-dimensional rectangle representation on a current domain + * + * @param ndRectangle The ndrectangle * @throws TileDBError */ public void setNDRectangle(NDRectangle ndRectangle) throws TileDBError { @@ -56,7 +66,9 @@ public void setNDRectangle(NDRectangle ndRectangle) throws TileDBError { } /** - * @return + * Returns the currentDomain type. + * + * @return The type * @throws TileDBError */ public CurrentDomainType getType() throws TileDBError { @@ -73,7 +85,10 @@ public CurrentDomainType getType() throws TileDBError { } /** - * @return + * Get the N-dimensional rectangle associated with the current domain object, error if the current + * domain is empty or a different representation is set. + * + * @return The ndrectangle * @throws TileDBError */ public NDRectangle getNDRectangle() throws TileDBError { @@ -90,7 +105,9 @@ public NDRectangle getNDRectangle() throws TileDBError { } /** - * @return + * Return true if the current domain is empty + * + * @return True if empty * @throws TileDBError */ public boolean isEmpty() throws TileDBError { diff --git a/src/main/java/io/tiledb/java/api/NDRectangle.java b/src/main/java/io/tiledb/java/api/NDRectangle.java index 2ad4d5ec..93a3e90d 100644 --- a/src/main/java/io/tiledb/java/api/NDRectangle.java +++ b/src/main/java/io/tiledb/java/api/NDRectangle.java @@ -9,8 +9,10 @@ public class NDRectangle implements AutoCloseable { private Domain domain; /** - * @param ctx - * @param domain + * Constructor + * + * @param ctx The TileDB context + * @param domain The array domain * @throws TileDBError */ public NDRectangle(Context ctx, Domain domain) throws TileDBError { @@ -28,9 +30,11 @@ public NDRectangle(Context ctx, Domain domain) throws TileDBError { } /** - * @param ctx - * @param domain - * @param ndpp + * Constructor + * + * @param ctx The TileDB context + * @param domain The array domain + * @param ndpp The c pointer to the ndrectangle object */ protected NDRectangle(Context ctx, Domain domain, SWIGTYPE_p_p_tiledb_ndrectangle_t ndpp) { this.ctx = ctx; @@ -39,27 +43,36 @@ protected NDRectangle(Context ctx, Domain domain, SWIGTYPE_p_p_tiledb_ndrectangl this.domain = domain; } + /** + * Getter for the c pointer + * + * @return The c pointer + */ public SWIGTYPE_p_tiledb_ndrectangle_t getndrectanglep() { return ndrectanglep; } /** - * @param dimIdx - * @param range + * Adds an 1D range along a dimension name, in the form (start, end). + * + * @param dimIdx The index of the dimension to add the range to + * @param range The range * @throws TileDBError */ - public void setRange(long dimIdx, Range range) throws TileDBError { // todo + name + public void setRange(long dimIdx, Range range) throws TileDBError { ctx.handleError( tiledb.tiledb_ndrectangle_set_range( ctx.getCtxp(), this.ndrectanglep, dimIdx, range.getRange_t())); } /** - * @param dimIdx - * @return + * Retrieves a range for a given dimension index. + * + * @param dimIdx The dimension index + * @return The range * @throws TileDBError */ - public Range getRange(long dimIdx) throws TileDBError { // todo + name + public Range getRange(long dimIdx) throws TileDBError { tiledb_range_t range = new tiledb_range_t(); ctx.handleError( diff --git a/src/main/java/io/tiledb/java/api/Range.java b/src/main/java/io/tiledb/java/api/Range.java index 89ee6ecb..2ddc001a 100644 --- a/src/main/java/io/tiledb/java/api/Range.java +++ b/src/main/java/io/tiledb/java/api/Range.java @@ -10,13 +10,28 @@ public class Range implements AutoCloseable { private Long dimIdx; private NativeArray min, max; - public Range(Context cxt, Domain domain, long dimIdx) { + /** + * Constructor + * + * @param ctx The TileDB context + * @param domain The array domain + * @param dimIdx The dimension index to add the range to + */ + public Range(Context ctx, Domain domain, long dimIdx) { this.domain = domain; - this.ctx = cxt; + this.ctx = ctx; this.range = new tiledb_range_t(); this.dimIdx = dimIdx; } + /** + * Constructor + * + * @param ctx The TileDB context + * @param range C pointer to the range + * @param domain The array domain + * @param dimIdx The dimension index to add the range to + */ public Range(Context ctx, tiledb_range_t range, Domain domain, long dimIdx) { this.ctx = ctx; this.range = range; @@ -25,7 +40,9 @@ public Range(Context ctx, tiledb_range_t range, Domain domain, long dimIdx) { } /** - * @param min + * Sets the min value for this range + * + * @param min The min value * @throws TileDBError */ public synchronized void setMin(Object min) throws TileDBError { @@ -40,32 +57,52 @@ public synchronized void setMin(Object min) throws TileDBError { NativeArray minArr = new NativeArray(ctx, 1, dimType); minArr.setItem(0, min); - range.setMin_size(BigInteger.valueOf(dimType.getNativeSize())); + if (!dimType.isStringType()) { + setMinSize(BigInteger.valueOf(dimType.getNativeSize())); + } range.setMin(minArr.toVoidPointer()); } - /** @param size */ + /** + * Sets the min size + * + * @param size The size + */ public synchronized void setMinSize(long size) { range.setMin_size(BigInteger.valueOf(size)); } - /** @param size */ - public synchronized void setMinSize(BigInteger size) { // change to bigint + /** + * Sets the min size + * + * @param size The size + */ + public synchronized void setMinSize(BigInteger size) { range.setMin_size(size); } - /** @return */ + /** + * Retrieves the min value size + * + * @return The size as a long + */ public synchronized long getMinSize() { return range.getMin_size().longValue(); } - /** @return */ + /** + * Retrieves the min value size + * + * @return The size as a BigInteger + */ public synchronized BigInteger getMinSizeBI() { return range.getMin_size(); } /** - * @param max + * Sets the max value for this range + * + * @param max The max value * @throws TileDBError */ public synchronized void setMax(Object max) throws TileDBError { @@ -81,32 +118,52 @@ public synchronized void setMax(Object max) throws TileDBError { NativeArray maxArr = new NativeArray(ctx, 1, dimType); maxArr.setItem(0, max); - range.setMax_size(BigInteger.valueOf(dimType.getNativeSize())); + if (!dimType.isStringType()) { + setMaxSize(BigInteger.valueOf(dimType.getNativeSize())); + } range.setMax(maxArr.toVoidPointer()); } - /** @param size */ + /** + * Sets the max size + * + * @param size The size + */ public synchronized void setMaxSize(long size) { range.setMax_size(BigInteger.valueOf(size)); } - /** @param size */ + /** + * Sets the max size + * + * @param size The size + */ public synchronized void setMaxSize(BigInteger size) { range.setMax_size(size); } - /** @return */ + /** + * Retrieves the max value size + * + * @return The size as a long + */ public synchronized long getMaxSize() { return range.getMax_size().longValue(); } - /** @return */ + /** + * Retrieves the max value size + * + * @return The size as a BigInteger + */ public synchronized BigInteger getMaxSizeBI() { return range.getMax_size(); } /** - * @return + * Returns the min range value + * + * @return the value * @throws TileDBError */ public synchronized Object getMin() throws TileDBError { @@ -122,7 +179,21 @@ public synchronized Object getMin() throws TileDBError { } /** - * @return + * Returns the min range value for var dims + * + * @return The value + * @throws TileDBError + */ + public synchronized String getMinVar() throws TileDBError { + SWIGTYPE_p_void minp = range.getMin(); + min = new NativeArray(ctx, Datatype.TILEDB_BLOB, minp, (int) getMinSize()); + return new String((byte[]) min.toJavaArray()); + } + + /** + * Returns the max range value + * + * @return the max value * @throws TileDBError */ public synchronized Object getMax() throws TileDBError { @@ -137,7 +208,23 @@ public synchronized Object getMax() throws TileDBError { } } - /** @return */ + /** + * Returns the max value fo a var dim + * + * @return The max value + * @throws TileDBError + */ + public synchronized String getMaxVar() throws TileDBError { + SWIGTYPE_p_void maxp = range.getMax(); + max = new NativeArray(ctx, Datatype.TILEDB_BLOB, maxp, (int) getMaxSize()); + return new String((byte[]) max.toJavaArray()); + } + + /** + * Returns the c pointer fot his range + * + * @return The c pointer + */ public tiledb_range_t getRange_t() { return range; } diff --git a/src/test/java/io/tiledb/java/api/TestCurrentDomain.java b/src/test/java/io/tiledb/java/api/TestCurrentDomain.java index 6870b9b1..c4d3b3e2 100644 --- a/src/test/java/io/tiledb/java/api/TestCurrentDomain.java +++ b/src/test/java/io/tiledb/java/api/TestCurrentDomain.java @@ -26,16 +26,25 @@ public void setup() throws Exception { schema = new ArraySchema(ctx, ArrayType.TILEDB_SPARSE); Dimension d1 = new Dimension(ctx, "d1", Datatype.TILEDB_INT64, new Pair(1l, 4l), 1l); + Dimension d2 = new Dimension<>(ctx, "d2", Datatype.TILEDB_STRING_ASCII, null, null); domain = new Domain(ctx); domain.addDimension(d1); + domain.addDimension(d2); schema.setDomain(domain); Range range = new Range(ctx, domain, 0); range.setMin(1L); range.setMax(3L); + Range rangeVar = new Range(ctx, domain, 1); + rangeVar.setMin("aa"); + rangeVar.setMinSize(2); + rangeVar.setMax("bbb"); + rangeVar.setMaxSize(3); + NDRectangle ndRectangle = new NDRectangle(ctx, domain); ndRectangle.setRange(0, range); + ndRectangle.setRange(1, rangeVar); CurrentDomain currentDomain = new CurrentDomain(ctx, domain); currentDomain.setNDRectangle(ndRectangle); @@ -80,16 +89,33 @@ public void currentDomainTest() throws TileDBError { // Evolution test ArraySchemaEvolution schemaEvolution = new ArraySchemaEvolution(ctx); + Range newRange = new Range(ctx, domain, 0); newRange.setMin(1L); newRange.setMax(4L); + Range newRangeVar = new Range(ctx, domain, 1); + newRangeVar.setMin("aa"); + newRangeVar.setMinSize(2); + newRangeVar.setMax("bbb"); + newRangeVar.setMaxSize(3); + CurrentDomain newCurrentDomain = new CurrentDomain(ctx, domain); NDRectangle newND = new NDRectangle(ctx, domain); newND.setRange(0, newRange); + newND.setRange(1, newRangeVar); newCurrentDomain.setNDRectangle(newND); schemaEvolution.expandCurrentDomain(newCurrentDomain); schemaEvolution.evolveArray(arrayUri); + Assert.assertEquals( + 4L, + new Array(ctx, arrayUri, TILEDB_READ) + .getSchema() + .getCurrentDomain() + .getNDRectangle() + .getRange(0) + .getMax()); + // clean up newRange.close(); array.close(); @@ -97,4 +123,21 @@ public void currentDomainTest() throws TileDBError { newND.close(); newCurrentDomain.close(); } + + @Test + public void currentDomainVarTest() throws TileDBError { + Array array = new Array(ctx, arrayUri, TILEDB_READ); + ArraySchema schema = array.getSchema(); + + CurrentDomain cd = schema.getCurrentDomain(); + Assert.assertFalse(cd.isEmpty()); + + Assert.assertEquals(TILEDB_NDRECTANGLE, cd.getType()); + + NDRectangle nd = cd.getNDRectangle(); + Range range = nd.getRange(1); + + Assert.assertEquals("aa", range.getMinVar()); + Assert.assertEquals("bbb", range.getMaxVar()); + } } From 98e3fc16c3dbea4f2ffe8e9fa1ff2614862da1eb Mon Sep 17 00:00:00 2001 From: dimitrisstaratzis Date: Thu, 29 Aug 2024 16:33:02 +0300 Subject: [PATCH 4/4] remove ```synchronized``` from Range.java --- src/main/java/io/tiledb/java/api/Range.java | 28 ++++++++++----------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/main/java/io/tiledb/java/api/Range.java b/src/main/java/io/tiledb/java/api/Range.java index 2ddc001a..578b4420 100644 --- a/src/main/java/io/tiledb/java/api/Range.java +++ b/src/main/java/io/tiledb/java/api/Range.java @@ -45,7 +45,7 @@ public Range(Context ctx, tiledb_range_t range, Domain domain, long dimIdx) { * @param min The min value * @throws TileDBError */ - public synchronized void setMin(Object min) throws TileDBError { + public void setMin(Object min) throws TileDBError { Datatype dimType; dimType = domain.getDimension(dimIdx).getType(); @@ -68,7 +68,7 @@ public synchronized void setMin(Object min) throws TileDBError { * * @param size The size */ - public synchronized void setMinSize(long size) { + public void setMinSize(long size) { range.setMin_size(BigInteger.valueOf(size)); } @@ -77,7 +77,7 @@ public synchronized void setMinSize(long size) { * * @param size The size */ - public synchronized void setMinSize(BigInteger size) { + public void setMinSize(BigInteger size) { range.setMin_size(size); } @@ -86,7 +86,7 @@ public synchronized void setMinSize(BigInteger size) { * * @return The size as a long */ - public synchronized long getMinSize() { + public long getMinSize() { return range.getMin_size().longValue(); } @@ -95,7 +95,7 @@ public synchronized long getMinSize() { * * @return The size as a BigInteger */ - public synchronized BigInteger getMinSizeBI() { + public BigInteger getMinSizeBI() { return range.getMin_size(); } @@ -105,7 +105,7 @@ public synchronized BigInteger getMinSizeBI() { * @param max The max value * @throws TileDBError */ - public synchronized void setMax(Object max) throws TileDBError { + public void setMax(Object max) throws TileDBError { Datatype dimType; dimType = domain.getDimension(dimIdx).getType(); @@ -129,7 +129,7 @@ public synchronized void setMax(Object max) throws TileDBError { * * @param size The size */ - public synchronized void setMaxSize(long size) { + public void setMaxSize(long size) { range.setMax_size(BigInteger.valueOf(size)); } @@ -138,7 +138,7 @@ public synchronized void setMaxSize(long size) { * * @param size The size */ - public synchronized void setMaxSize(BigInteger size) { + public void setMaxSize(BigInteger size) { range.setMax_size(size); } @@ -147,7 +147,7 @@ public synchronized void setMaxSize(BigInteger size) { * * @return The size as a long */ - public synchronized long getMaxSize() { + public long getMaxSize() { return range.getMax_size().longValue(); } @@ -156,7 +156,7 @@ public synchronized long getMaxSize() { * * @return The size as a BigInteger */ - public synchronized BigInteger getMaxSizeBI() { + public BigInteger getMaxSizeBI() { return range.getMax_size(); } @@ -166,7 +166,7 @@ public synchronized BigInteger getMaxSizeBI() { * @return the value * @throws TileDBError */ - public synchronized Object getMin() throws TileDBError { + public Object getMin() throws TileDBError { Datatype dimType; try (Dimension dim = domain.getDimension(dimIdx)) { dimType = dim.getType(); @@ -184,7 +184,7 @@ public synchronized Object getMin() throws TileDBError { * @return The value * @throws TileDBError */ - public synchronized String getMinVar() throws TileDBError { + public String getMinVar() throws TileDBError { SWIGTYPE_p_void minp = range.getMin(); min = new NativeArray(ctx, Datatype.TILEDB_BLOB, minp, (int) getMinSize()); return new String((byte[]) min.toJavaArray()); @@ -196,7 +196,7 @@ public synchronized String getMinVar() throws TileDBError { * @return the max value * @throws TileDBError */ - public synchronized Object getMax() throws TileDBError { + public Object getMax() throws TileDBError { Datatype dimType; try (Dimension dim = domain.getDimension(dimIdx)) { dimType = dim.getType(); @@ -214,7 +214,7 @@ public synchronized Object getMax() throws TileDBError { * @return The max value * @throws TileDBError */ - public synchronized String getMaxVar() throws TileDBError { + public String getMaxVar() throws TileDBError { SWIGTYPE_p_void maxp = range.getMax(); max = new NativeArray(ctx, Datatype.TILEDB_BLOB, maxp, (int) getMaxSize()); return new String((byte[]) max.toJavaArray());