From dbd7683126df243d1cef12c23aded41e311e9134 Mon Sep 17 00:00:00 2001 From: gsvic Date: Mon, 13 Jul 2020 21:09:30 +0300 Subject: [PATCH 1/5] Added ByteBuffer support for var-sized attributes --- src/main/c/generated/tiledb_wrap.cxx | 33 ++++++ src/main/java/io/tiledb/java/api/Query.java | 75 +++++++++++++ src/main/java/io/tiledb/libtiledb/tiledb.java | 18 ++++ .../java/io/tiledb/libtiledb/tiledbJNI.java | 9 ++ .../java/io/tiledb/java/api/QueryTest.java | 102 +++++++++++++++++- 5 files changed, 235 insertions(+), 2 deletions(-) diff --git a/src/main/c/generated/tiledb_wrap.cxx b/src/main/c/generated/tiledb_wrap.cxx index baaee3fd..47a4c1b3 100644 --- a/src/main/c/generated/tiledb_wrap.cxx +++ b/src/main/c/generated/tiledb_wrap.cxx @@ -7075,6 +7075,39 @@ SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1set_1b return jresult; } +SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1set_1buffer_1var_1nio(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jobject jarg4, jlong jarg5, jobject jarg6, jlong jarg7) { + void* offsets = (void *)jenv->GetDirectBufferAddress(jarg4); + void* buffer = (void *)jenv->GetDirectBufferAddress(jarg6); + + jint jresult = 0 ; + tiledb_ctx_t *arg1 = (tiledb_ctx_t *) 0 ; + tiledb_query_t *arg2 = (tiledb_query_t *) 0 ; + char *arg3 = (char *) 0 ; + uint64_t *arg4 = (uint64_t *) 0 ; + uint64_t *arg5 = (uint64_t *) 0 ; + void *arg6 = (void *) 0 ; + uint64_t *arg7 = (uint64_t *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(tiledb_ctx_t **)&jarg1; + arg2 = *(tiledb_query_t **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(uint64_t **)&jarg4; + arg5 = *(uint64_t **)&jarg5; + arg6 = *(void **)&jarg6; + arg7 = *(uint64_t **)&jarg7; + result = (int32_t)tiledb_query_set_buffer_var(arg1,arg2,(char const *)arg3,(uint64_t *)offsets,arg5,buffer,arg7); + jresult = (jint)result; + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + SWIGEXPORT jint JNICALL Java_io_tiledb_libtiledb_tiledbJNI_tiledb_1query_1get_1buffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5) { jint jresult = 0 ; diff --git a/src/main/java/io/tiledb/java/api/Query.java b/src/main/java/io/tiledb/java/api/Query.java index bf718a66..d8fa432b 100644 --- a/src/main/java/io/tiledb/java/api/Query.java +++ b/src/main/java/io/tiledb/java/api/Query.java @@ -61,6 +61,7 @@ public class Query implements AutoCloseable { private Map buffers_; private Map byteBuffers_; + private Map> varByteBuffers_; private Map> var_buffers_; private Map> buffer_sizes_; @@ -82,6 +83,7 @@ public Query(Array array, QueryType type) throws TileDBError { this.queryp = tiledb.tiledb_query_tpp_value(_querypp); this.buffers_ = Collections.synchronizedMap(new HashMap<>()); this.byteBuffers_ = Collections.synchronizedMap(new HashMap<>()); + this.varByteBuffers_ = Collections.synchronizedMap(new HashMap<>()); this.var_buffers_ = Collections.synchronizedMap(new HashMap<>()); this.buffer_sizes_ = Collections.synchronizedMap(new HashMap<>()); } @@ -132,6 +134,14 @@ public QueryStatus submit() throws TileDBError { this.byteBuffers_.get(attribute).limit(nbytes); } + // Set the actual number of bytes received to each ByteBuffer + for (String attribute : varByteBuffers_.keySet()) { + int offset_nbytes = this.buffer_sizes_.get(attribute).getFirst().getitem(0).intValue(); + int data_nbytes = this.buffer_sizes_.get(attribute).getSecond().getitem(0).intValue(); + this.varByteBuffers_.get(attribute).getFirst().limit(offset_nbytes); + this.varByteBuffers_.get(attribute).getSecond().limit(data_nbytes); + } + return getQueryStatus(); } @@ -532,6 +542,11 @@ public synchronized ByteBuffer setBuffer(String attr, ByteBuffer buffer) throws "The ByteBuffer provided is not direct. Please provide a direct buffer (ByteBuffer.allocateDirect(...))"); } + if (!buffer.order().equals(ByteOrder.nativeOrder()) && buffer.position() > 0) { + throw new TileDBError( + "The order of the data ByteBuffer should be the same as the native order (ByteOrder.nativeOrder()) before values are inserted."); + } + if (!buffer.order().equals(ByteOrder.nativeOrder())) { // TODO: Add a logger component to Query class and a WARN here buffer.order(ByteOrder.nativeOrder()); @@ -623,6 +638,66 @@ public synchronized Query setBuffer(String attr, NativeArray offsets, NativeArra return this; } + /** + * Sets a ByteBuffer buffer for a variable-sized getAttribute. + * + * @param attr Attribute name + * @param offsets Offsets where a new element begins in the data buffer. + * @param buffer Buffer vector with elements of the attribute type. + * @exception TileDBError A TileDB exception + */ + public synchronized Query setBuffer(String attr, ByteBuffer offsets, ByteBuffer buffer) + throws TileDBError { + + if (attr.equals(tiledb.tiledb_coords())) { + throw new TileDBError("Cannot set coordinate buffer as variable sized."); + } + + if (!offsets.order().equals(ByteOrder.nativeOrder()) && offsets.position() > 0) { + throw new TileDBError( + "The order of the offsets ByteBuffer should be the same as the native order (ByteOrder.nativeOrder()) before values are inserted."); + } + + if (!buffer.order().equals(ByteOrder.nativeOrder()) && buffer.position() > 0) { + throw new TileDBError( + "The order of the data ByteBuffer should be the same as the native order (ByteOrder.nativeOrder()) before values are inserted."); + } + + offsets.order(ByteOrder.nativeOrder()); + buffer.order(ByteOrder.nativeOrder()); + + uint64_tArray offsets_array_size = new uint64_tArray(1); + uint64_tArray values_array_size = new uint64_tArray(1); + + offsets_array_size.setitem(0, BigInteger.valueOf(offsets.capacity())); + values_array_size.setitem(0, BigInteger.valueOf(buffer.capacity())); + + Pair buffer_sizes = + new Pair<>(offsets_array_size, values_array_size); + + // Close previous buffers if they exist for this attribute + if (var_buffers_.containsKey(attr)) { + Pair prev_buffers = var_buffers_.get(attr); + prev_buffers.getFirst().close(); + prev_buffers.getSecond().close(); + } + + buffer_sizes_.put(attr, buffer_sizes); + this.varByteBuffers_.put(attr, new Pair(offsets, buffer)); + + ctx.handleError( + tiledb.tiledb_query_set_buffer_var_nio( + ctx.getCtxp(), + queryp, + attr, + offsets, + offsets_array_size.cast(), + buffer, + values_array_size.cast())); + + return this; + } + /** * Sets a buffer for a variable-sized getAttribute. * diff --git a/src/main/java/io/tiledb/libtiledb/tiledb.java b/src/main/java/io/tiledb/libtiledb/tiledb.java index f917253f..27d58ae3 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledb.java +++ b/src/main/java/io/tiledb/libtiledb/tiledb.java @@ -2165,6 +2165,24 @@ public static int tiledb_query_set_buffer_var( SWIGTYPE_p_unsigned_long_long.getCPtr(buffer_val_size)); } + public static int tiledb_query_set_buffer_var_nio( + SWIGTYPE_p_tiledb_ctx_t ctx, + SWIGTYPE_p_tiledb_query_t query, + String name, + ByteBuffer buffer_off, + SWIGTYPE_p_unsigned_long_long buffer_off_size, + ByteBuffer buffer_val, + SWIGTYPE_p_unsigned_long_long buffer_val_size) { + return tiledbJNI.tiledb_query_set_buffer_var_nio( + SWIGTYPE_p_tiledb_ctx_t.getCPtr(ctx), + SWIGTYPE_p_tiledb_query_t.getCPtr(query), + name, + buffer_off, + SWIGTYPE_p_unsigned_long_long.getCPtr(buffer_off_size), + buffer_val, + SWIGTYPE_p_unsigned_long_long.getCPtr(buffer_val_size)); + } + public static int tiledb_query_get_buffer( SWIGTYPE_p_tiledb_ctx_t ctx, SWIGTYPE_p_tiledb_query_t query, diff --git a/src/main/java/io/tiledb/libtiledb/tiledbJNI.java b/src/main/java/io/tiledb/libtiledb/tiledbJNI.java index af41d83c..4862f2a7 100644 --- a/src/main/java/io/tiledb/libtiledb/tiledbJNI.java +++ b/src/main/java/io/tiledb/libtiledb/tiledbJNI.java @@ -928,6 +928,15 @@ public static final native int tiledb_query_set_buffer_nio( public static final native int tiledb_query_set_buffer_var( long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6, long jarg7); + public static final native int tiledb_query_set_buffer_var_nio( + long jarg1, + long jarg2, + String jarg3, + ByteBuffer jarg4, + long jarg5, + ByteBuffer jarg6, + long jarg7); + public static final native int tiledb_query_get_buffer( long jarg1, long jarg2, String jarg3, long jarg4, long jarg5); diff --git a/src/test/java/io/tiledb/java/api/QueryTest.java b/src/test/java/io/tiledb/java/api/QueryTest.java index aeb667ff..89a2537c 100644 --- a/src/test/java/io/tiledb/java/api/QueryTest.java +++ b/src/test/java/io/tiledb/java/api/QueryTest.java @@ -2,6 +2,7 @@ import static io.tiledb.java.api.ArrayType.TILEDB_DENSE; import static io.tiledb.java.api.ArrayType.TILEDB_SPARSE; +import static io.tiledb.java.api.Constants.TILEDB_VAR_NUM; import static io.tiledb.java.api.Layout.TILEDB_GLOBAL_ORDER; import static io.tiledb.java.api.Layout.TILEDB_ROW_MAJOR; import static io.tiledb.java.api.QueryType.TILEDB_READ; @@ -10,6 +11,7 @@ import java.math.BigInteger; import java.nio.ByteBuffer; import java.nio.ByteOrder; +import java.nio.charset.StandardCharsets; import java.util.HashMap; import org.junit.Assert; import org.junit.Before; @@ -185,8 +187,6 @@ public static class NIODenseTests { public void setup() throws Exception { ctx = new Context(); arrayURI = temp.getRoot().toPath().resolve("query").toString(); - arrayCreate(); - arrayWrite(); } public void arrayCreate() throws Exception { @@ -206,6 +206,8 @@ public void arrayCreate() throws Exception { Attribute a1 = new Attribute(ctx, "a1", Character.class); Attribute a2 = new Attribute(ctx, "a2", Float.class); a2.setCellValNum(2); + Attribute a3 = new Attribute(ctx, "a3", Datatype.TILEDB_CHAR); + a3.setCellValNum(TILEDB_VAR_NUM); ArraySchema schema = new ArraySchema(ctx, TILEDB_DENSE); schema.setTileOrder(TILEDB_ROW_MAJOR); @@ -250,8 +252,62 @@ public void arrayWrite() throws Exception { } } + public void arrayWithVarAttrCreate() throws Exception { + // The array will be 4x4 with dimensions "rows" and "cols", with domain [1,4]. + Dimension rows = + new Dimension<>(ctx, "rows", Integer.class, new Pair(1, 8), 2); + + // Create and set getDomain + Domain domain = new Domain(ctx); + domain.addDimension(rows); + + // Add two attributes "a1" and "a2", so each (i,j) cell can store + // a character on "a1" and a vector of two floats on "a2". + Attribute a1 = new Attribute(ctx, "a1", Datatype.TILEDB_CHAR); + a1.setCellValNum(TILEDB_VAR_NUM); + + ArraySchema schema = new ArraySchema(ctx, TILEDB_DENSE); + schema.setTileOrder(TILEDB_ROW_MAJOR); + schema.setCellOrder(TILEDB_ROW_MAJOR); + schema.setDomain(domain); + schema.addAttribute(a1); + + Array.create(arrayURI, schema); + } + + public void arrayWithVarAttrWrite() throws Exception { + // Prepare cell buffers + String str = "aabbccddeeffgghh"; + long[] offsets = new long[] {0, 2, 4, 6, 8, 10, 12, 14}; + + // NativeArray a2 = new NativeArray(ctx, "aabbccddeeffgghh", Datatype.TILEDB_CHAR); + // NativeArray a2_off = new NativeArray(ctx, new long[]{0, 2, 4, 6, 8, 10, 12, 14}, + // Datatype.TILEDB_UINT64); + + ByteBuffer a1 = ByteBuffer.allocateDirect(str.length()); + ByteBuffer a1_off = ByteBuffer.allocateDirect(offsets.length * 8); + + a1.order(ByteOrder.nativeOrder()); + a1_off.order(ByteOrder.nativeOrder()); + + a1.put(str.getBytes(StandardCharsets.US_ASCII)); + for (long x : offsets) a1_off.putLong(x); + + // Create query + try (Array array = new Array(ctx, arrayURI, TILEDB_WRITE); + Query query = new Query(array)) { + query.setLayout(TILEDB_ROW_MAJOR); + query.setBuffer("a1", a1_off, a1); + // Submit query + query.submit(); + } + } + @Test public void queryTestNIOReadArray() throws Exception { + arrayCreate(); + arrayWrite(); + Array array = new Array(ctx, arrayURI, TILEDB_READ); Query query = new Query(array, TILEDB_READ); @@ -290,6 +346,9 @@ public void queryTestNIOReadArray() throws Exception { @Test public void queryTestNIOReadArrayArbitrarySize() throws Exception { + arrayCreate(); + arrayWrite(); + Array array = new Array(ctx, arrayURI, TILEDB_READ); Query query = new Query(array, TILEDB_READ); @@ -328,6 +387,9 @@ public void queryTestNIOReadArrayArbitrarySize() throws Exception { @Test public void arrayReadTest() throws Exception { + arrayCreate(); + arrayWrite(); + // Create array and query try (Array array = new Array(ctx, arrayURI, TILEDB_READ); Query query = new Query(array, TILEDB_READ)) { @@ -379,6 +441,9 @@ public void arrayReadTest() throws Exception { @Test public void arrayReadTestCustomBufferWithDifferentOrder() throws Exception { + arrayCreate(); + arrayWrite(); + // Create array and query try (Array array = new Array(ctx, arrayURI, TILEDB_READ); Query query = new Query(array, TILEDB_READ)) { @@ -438,6 +503,9 @@ public void arrayReadTestCustomBufferWithDifferentOrder() throws Exception { @Test public void queryTestNIOGetByteBuffer() throws Exception { + arrayCreate(); + arrayWrite(); + Array array = new Array(ctx, arrayURI, TILEDB_READ); Query query = new Query(array, TILEDB_READ); @@ -453,6 +521,9 @@ public void queryTestNIOGetByteBuffer() throws Exception { @Test() public void queryTestNIOGetByteBuffeErrors() throws Exception { + arrayCreate(); + arrayWrite(); + Array array = new Array(ctx, arrayURI, TILEDB_READ); Query query = new Query(array, TILEDB_READ); @@ -476,6 +547,33 @@ public void queryTestNIOGetByteBuffeErrors() throws Exception { ByteBuffer b = query.setBuffer("rows", ByteBuffer.allocateDirect(bufferSize).order(order)); Assert.assertEquals(b.order(), ByteOrder.nativeOrder()); } + + @Test() + public void queryTestNIOSetBufferVarChar() throws Exception { + arrayWithVarAttrCreate(); + arrayWithVarAttrWrite(); + + ByteBuffer offsetsBuffer = ByteBuffer.allocateDirect(1000); + ByteBuffer dataBuffer = ByteBuffer.allocateDirect(1000); + + Query q = new Query(new Array(ctx, arrayURI), TILEDB_READ); + q.addRange(0, 1, 8); + q.setBuffer("a1", offsetsBuffer, dataBuffer); + q.submit(); + + long[] offsets = new long[8]; + char[] data = new char[16]; + + int idx = 0; + + while (offsetsBuffer.hasRemaining()) offsets[idx++] = offsetsBuffer.getLong(); + + idx = 0; + while (dataBuffer.hasRemaining()) data[idx++] = (char) dataBuffer.get(); + + Assert.assertArrayEquals(new long[] {0, 2, 4, 6, 8, 10, 12, 14}, offsets); + Assert.assertEquals("aabbccddeeffgghh", new String(data)); + } } public static class SparseTests { From 37f2c83e7bd392b3a735cb1ee02f3bd7963bf282 Mon Sep 17 00:00:00 2001 From: gsvic Date: Mon, 13 Jul 2020 21:17:31 +0300 Subject: [PATCH 2/5] Changed setBuffer to return the Query instance instead of the ByteBuffer --- src/main/java/io/tiledb/java/api/Query.java | 14 ++--- .../java/io/tiledb/java/api/QueryTest.java | 54 +++++++++++-------- 2 files changed, 41 insertions(+), 27 deletions(-) diff --git a/src/main/java/io/tiledb/java/api/Query.java b/src/main/java/io/tiledb/java/api/Query.java index d8fa432b..aee0eed4 100644 --- a/src/main/java/io/tiledb/java/api/Query.java +++ b/src/main/java/io/tiledb/java/api/Query.java @@ -496,7 +496,7 @@ public synchronized Query setBuffer(String attr, NativeArray buffer, long buffer * @return The NIO ByteBuffer * @throws TileDBError */ - public synchronized ByteBuffer setBuffer(String attr, long bufferElements) throws TileDBError { + public synchronized Query setBuffer(String attr, long bufferElements) throws TileDBError { if (bufferElements <= 0) { throw new TileDBError("Number of buffer elements must be >= 1"); } @@ -521,7 +521,7 @@ public synchronized ByteBuffer setBuffer(String attr, long bufferElements) throw this.setBuffer(attr, buffer); - return buffer; + return this; } /** @@ -532,7 +532,7 @@ public synchronized ByteBuffer setBuffer(String attr, long bufferElements) throw * @return The NIO ByteBuffer * @throws TileDBError */ - public synchronized ByteBuffer setBuffer(String attr, ByteBuffer buffer) throws TileDBError { + public synchronized Query setBuffer(String attr, ByteBuffer buffer) throws TileDBError { if (buffer.capacity() <= 0) { throw new TileDBError("Number of buffer elements must be >= 1"); } @@ -566,7 +566,7 @@ public synchronized ByteBuffer setBuffer(String attr, ByteBuffer buffer) throws tiledb.tiledb_query_set_buffer_nio( ctx.getCtxp(), queryp, attr, buffer, values_array_size.cast())); - return buffer; + return this; } /** @@ -1054,8 +1054,10 @@ public Object getBuffer(String attr) throws TileDBError { * @return The ByteBuffer * @throws TileDBError A TileDB exception */ - public ByteBuffer getByteBuffer(String attr) throws TileDBError { - if (byteBuffers_.containsKey(attr)) return byteBuffers_.get(attr); + public Pair getByteBuffer(String attr) throws TileDBError { + if (byteBuffers_.containsKey(attr)) return new Pair(null, byteBuffers_.get(attr)); + else if (varByteBuffers_.containsKey(attr)) + return new Pair(varByteBuffers_.get(attr).getFirst(), varByteBuffers_.get(attr).getSecond()); else throw new TileDBError("ByteBuffer does not exist for attribute: " + attr); } diff --git a/src/test/java/io/tiledb/java/api/QueryTest.java b/src/test/java/io/tiledb/java/api/QueryTest.java index 89a2537c..7be866b2 100644 --- a/src/test/java/io/tiledb/java/api/QueryTest.java +++ b/src/test/java/io/tiledb/java/api/QueryTest.java @@ -314,8 +314,10 @@ public void queryTestNIOReadArray() throws Exception { int bufferSize = 4; - ByteBuffer d1 = query.setBuffer("rows", bufferSize); - ByteBuffer d2 = query.setBuffer("cols", bufferSize); + query.setBuffer("rows", bufferSize); + query.setBuffer("cols", bufferSize); + ByteBuffer d1 = query.getByteBuffer("rows").getSecond(); + ByteBuffer d2 = query.getByteBuffer("cols").getSecond(); query.addRange(0, 1, 4); query.addRange(1, 1, 4); @@ -354,9 +356,10 @@ public void queryTestNIOReadArrayArbitrarySize() throws Exception { Query query = new Query(array, TILEDB_READ); int bufferSize = 4; - - ByteBuffer d1 = query.setBuffer("rows", ByteBuffer.allocateDirect(10)); - ByteBuffer d2 = query.setBuffer("cols", ByteBuffer.allocateDirect(10)); + query.setBuffer("rows", ByteBuffer.allocateDirect(10)); + query.setBuffer("cols", ByteBuffer.allocateDirect(10)); + ByteBuffer d1 = query.getByteBuffer("rows").getSecond(); + ByteBuffer d2 = query.getByteBuffer("cols").getSecond(); query.addRange(0, 1, 4); query.addRange(1, 1, 4); @@ -399,10 +402,12 @@ public void arrayReadTest() throws Exception { query.addRange(1, 2, 4); query.setLayout(TILEDB_ROW_MAJOR); - ByteBuffer dim1Buffer = query.setBuffer("rows", 3); - ByteBuffer dim2Buffer = query.setBuffer("cols", 3); - ByteBuffer a1Buffer = query.setBuffer("a1", 3); - ByteBuffer a2Buffer = query.setBuffer("a2", 6); + query.setBuffer("rows", 3).setBuffer("cols", 3).setBuffer("a1", 3).setBuffer("a2", 6); + + ByteBuffer dim1Buffer = query.getByteBuffer("rows").getSecond(); + ByteBuffer dim2Buffer = query.getByteBuffer("cols").getSecond(); + ByteBuffer a1Buffer = query.getByteBuffer("a1").getSecond(); + ByteBuffer a2Buffer = query.getByteBuffer("a2").getSecond(); // Submit query query.submit(); @@ -459,12 +464,16 @@ public void arrayReadTestCustomBufferWithDifferentOrder() throws Exception { ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN; - ByteBuffer dim1Buffer = - query.setBuffer("rows", ByteBuffer.allocateDirect(3 * 4).order(order)); - ByteBuffer dim2Buffer = - query.setBuffer("cols", ByteBuffer.allocateDirect(3 * 4).order(order)); - ByteBuffer a1Buffer = query.setBuffer("a1", ByteBuffer.allocateDirect(3).order(order)); - ByteBuffer a2Buffer = query.setBuffer("a2", ByteBuffer.allocateDirect(6 * 4).order(order)); + query + .setBuffer("rows", ByteBuffer.allocateDirect(3 * 4).order(order)) + .setBuffer("cols", ByteBuffer.allocateDirect(3 * 4).order(order)) + .setBuffer("a1", ByteBuffer.allocateDirect(3).order(order)) + .setBuffer("a2", ByteBuffer.allocateDirect(6 * 4).order(order)); + + ByteBuffer dim1Buffer = query.getByteBuffer("rows").getSecond(); + ByteBuffer dim2Buffer = query.getByteBuffer("cols").getSecond(); + ByteBuffer a1Buffer = query.getByteBuffer("a1").getSecond(); + ByteBuffer a2Buffer = query.getByteBuffer("a2").getSecond(); // Submit query query.submit(); @@ -514,9 +523,9 @@ public void queryTestNIOGetByteBuffer() throws Exception { query.setBuffer("rows", bufferSize); - Assert.assertEquals(query.getByteBuffer("rows").capacity(), bufferSize * 4); - Assert.assertTrue(query.getByteBuffer("rows").isDirect()); - Assert.assertEquals(query.getByteBuffer("rows").order(), ByteOrder.nativeOrder()); + Assert.assertEquals(query.getByteBuffer("rows").getSecond().capacity(), bufferSize * 4); + Assert.assertTrue(query.getByteBuffer("rows").getSecond().isDirect()); + Assert.assertEquals(query.getByteBuffer("rows").getSecond().order(), ByteOrder.nativeOrder()); } @Test() @@ -544,7 +553,8 @@ public void queryTestNIOGetByteBuffeErrors() throws Exception { : ByteOrder.BIG_ENDIAN; // The Byte Order should be automatically changed to the native order - ByteBuffer b = query.setBuffer("rows", ByteBuffer.allocateDirect(bufferSize).order(order)); + query.setBuffer("rows", ByteBuffer.allocateDirect(bufferSize).order(order)); + ByteBuffer b = query.getByteBuffer("rows").getSecond(); Assert.assertEquals(b.order(), ByteOrder.nativeOrder()); } @@ -566,10 +576,12 @@ public void queryTestNIOSetBufferVarChar() throws Exception { int idx = 0; - while (offsetsBuffer.hasRemaining()) offsets[idx++] = offsetsBuffer.getLong(); + while (q.getByteBuffer("a1").getFirst().hasRemaining()) + offsets[idx++] = offsetsBuffer.getLong(); idx = 0; - while (dataBuffer.hasRemaining()) data[idx++] = (char) dataBuffer.get(); + while (q.getByteBuffer("a1").getSecond().hasRemaining()) + data[idx++] = (char) dataBuffer.get(); Assert.assertArrayEquals(new long[] {0, 2, 4, 6, 8, 10, 12, 14}, offsets); Assert.assertEquals("aabbccddeeffgghh", new String(data)); From 3a434d01ec8c37610a909358f21798ac8ebc8e44 Mon Sep 17 00:00:00 2001 From: gsvic Date: Mon, 13 Jul 2020 22:34:26 +0300 Subject: [PATCH 3/5] Integrate var-sized ByteBuffer map with the fix-sized ByteBuffer map --- src/main/java/io/tiledb/java/api/Query.java | 37 +++++++++++---------- 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/src/main/java/io/tiledb/java/api/Query.java b/src/main/java/io/tiledb/java/api/Query.java index aee0eed4..7a702c18 100644 --- a/src/main/java/io/tiledb/java/api/Query.java +++ b/src/main/java/io/tiledb/java/api/Query.java @@ -60,8 +60,7 @@ public class Query implements AutoCloseable { private NativeArray subarray; private Map buffers_; - private Map byteBuffers_; - private Map> varByteBuffers_; + private Map> byteBuffers_; private Map> var_buffers_; private Map> buffer_sizes_; @@ -83,7 +82,6 @@ public Query(Array array, QueryType type) throws TileDBError { this.queryp = tiledb.tiledb_query_tpp_value(_querypp); this.buffers_ = Collections.synchronizedMap(new HashMap<>()); this.byteBuffers_ = Collections.synchronizedMap(new HashMap<>()); - this.varByteBuffers_ = Collections.synchronizedMap(new HashMap<>()); this.var_buffers_ = Collections.synchronizedMap(new HashMap<>()); this.buffer_sizes_ = Collections.synchronizedMap(new HashMap<>()); } @@ -130,16 +128,21 @@ public QueryStatus submit() throws TileDBError { // Set the actual number of bytes received to each ByteBuffer for (String attribute : byteBuffers_.keySet()) { - int nbytes = this.buffer_sizes_.get(attribute).getSecond().getitem(0).intValue(); - this.byteBuffers_.get(attribute).limit(nbytes); - } - - // Set the actual number of bytes received to each ByteBuffer - for (String attribute : varByteBuffers_.keySet()) { - int offset_nbytes = this.buffer_sizes_.get(attribute).getFirst().getitem(0).intValue(); - int data_nbytes = this.buffer_sizes_.get(attribute).getSecond().getitem(0).intValue(); - this.varByteBuffers_.get(attribute).getFirst().limit(offset_nbytes); - this.varByteBuffers_.get(attribute).getSecond().limit(data_nbytes); + boolean isVar; + + if (array.getSchema().hasAttribute(attribute)) + isVar = array.getSchema().getAttribute(attribute).isVar(); + else isVar = array.getSchema().getDomain().getDimension(attribute).isVar(); + + if (isVar) { + int offset_nbytes = this.buffer_sizes_.get(attribute).getFirst().getitem(0).intValue(); + int data_nbytes = this.buffer_sizes_.get(attribute).getSecond().getitem(0).intValue(); + this.byteBuffers_.get(attribute).getFirst().limit(offset_nbytes); + this.byteBuffers_.get(attribute).getSecond().limit(data_nbytes); + } else { + int nbytes = this.buffer_sizes_.get(attribute).getSecond().getitem(0).intValue(); + this.byteBuffers_.get(attribute).getSecond().limit(nbytes); + } } return getQueryStatus(); @@ -552,7 +555,7 @@ public synchronized Query setBuffer(String attr, ByteBuffer buffer) throws TileD buffer.order(ByteOrder.nativeOrder()); } - this.byteBuffers_.put(attr, buffer); + this.byteBuffers_.put(attr, new Pair<>(null, buffer)); uint64_tArray offsets_array_size = new uint64_tArray(1); uint64_tArray values_array_size = new uint64_tArray(1); @@ -683,7 +686,7 @@ public synchronized Query setBuffer(String attr, ByteBuffer offsets, ByteBuffer } buffer_sizes_.put(attr, buffer_sizes); - this.varByteBuffers_.put(attr, new Pair(offsets, buffer)); + this.byteBuffers_.put(attr, new Pair(offsets, buffer)); ctx.handleError( tiledb.tiledb_query_set_buffer_var_nio( @@ -1055,9 +1058,7 @@ public Object getBuffer(String attr) throws TileDBError { * @throws TileDBError A TileDB exception */ public Pair getByteBuffer(String attr) throws TileDBError { - if (byteBuffers_.containsKey(attr)) return new Pair(null, byteBuffers_.get(attr)); - else if (varByteBuffers_.containsKey(attr)) - return new Pair(varByteBuffers_.get(attr).getFirst(), varByteBuffers_.get(attr).getSecond()); + if (byteBuffers_.containsKey(attr)) return this.byteBuffers_.get(attr); else throw new TileDBError("ByteBuffer does not exist for attribute: " + attr); } From c5d79aa0e995bcdf88a3cbd8b8205516a9424bf0 Mon Sep 17 00:00:00 2001 From: gsvic Date: Mon, 13 Jul 2020 22:59:56 +0300 Subject: [PATCH 4/5] Integrate var-sized NativeArray map with the fix-sized NativeArray map --- src/main/java/io/tiledb/java/api/Query.java | 130 ++++++++++---------- 1 file changed, 68 insertions(+), 62 deletions(-) diff --git a/src/main/java/io/tiledb/java/api/Query.java b/src/main/java/io/tiledb/java/api/Query.java index 7a702c18..76308765 100644 --- a/src/main/java/io/tiledb/java/api/Query.java +++ b/src/main/java/io/tiledb/java/api/Query.java @@ -59,9 +59,8 @@ public class Query implements AutoCloseable { private NativeArray subarray; - private Map buffers_; private Map> byteBuffers_; - private Map> var_buffers_; + private Map> buffers_; private Map> buffer_sizes_; public Query(Array array, QueryType type) throws TileDBError { @@ -82,7 +81,6 @@ public Query(Array array, QueryType type) throws TileDBError { this.queryp = tiledb.tiledb_query_tpp_value(_querypp); this.buffers_ = Collections.synchronizedMap(new HashMap<>()); this.byteBuffers_ = Collections.synchronizedMap(new HashMap<>()); - this.var_buffers_ = Collections.synchronizedMap(new HashMap<>()); this.buffer_sizes_ = Collections.synchronizedMap(new HashMap<>()); } @@ -130,9 +128,17 @@ public QueryStatus submit() throws TileDBError { for (String attribute : byteBuffers_.keySet()) { boolean isVar; - if (array.getSchema().hasAttribute(attribute)) - isVar = array.getSchema().getAttribute(attribute).isVar(); - else isVar = array.getSchema().getDomain().getDimension(attribute).isVar(); + try (ArraySchema arraySchema = array.getSchema()) { + if (arraySchema.hasAttribute(attribute)) { + try (Attribute attr = arraySchema.getAttribute(attribute)) { + isVar = attr.isVar(); + } + } else { + try (Dimension dim = arraySchema.getDomain().getDimension(attribute)) { + isVar = dim.isVar(); + } + } + } if (isVar) { int offset_nbytes = this.buffer_sizes_.get(attribute).getFirst().getitem(0).intValue(); @@ -414,10 +420,10 @@ public synchronized Query setBuffer(String attr, NativeArray buffer) throws Tile // Close previous buffers if they exist for this attribute if (buffers_.containsKey(attr)) { - buffers_.get(attr).close(); + buffers_.get(attr).getSecond().close(); } - buffers_.put(attr, buffer); + buffers_.put(attr, new Pair(null, buffer)); buffer_sizes_.put(attr, buffer_sizes); // Set the actual TileDB buffer @@ -475,10 +481,10 @@ public synchronized Query setBuffer(String attr, NativeArray buffer, long buffer // Close previous buffers if they exist for this attribute if (buffers_.containsKey(attr)) { - buffers_.get(attr).close(); + buffers_.get(attr).getSecond().close(); } - buffers_.put(attr, buffer); + buffers_.put(attr, new Pair(null, buffer)); buffer_sizes_.put(attr, buffer_sizes); // Set the actual TileDB buffer @@ -619,13 +625,13 @@ public synchronized Query setBuffer(String attr, NativeArray offsets, NativeArra new Pair<>(offsets_array_size, values_array_size); // Close previous buffers if they exist for this attribute - if (var_buffers_.containsKey(attr)) { - Pair prev_buffers = var_buffers_.get(attr); + if (buffers_.containsKey(attr)) { + Pair prev_buffers = buffers_.get(attr); prev_buffers.getFirst().close(); prev_buffers.getSecond().close(); } - var_buffers_.put(attr, new Pair<>(offsets, buffer)); + buffers_.put(attr, new Pair<>(offsets, buffer)); buffer_sizes_.put(attr, buffer_sizes); ctx.handleError( @@ -679,8 +685,8 @@ public synchronized Query setBuffer(String attr, ByteBuffer offsets, ByteBuffer new Pair<>(offsets_array_size, values_array_size); // Close previous buffers if they exist for this attribute - if (var_buffers_.containsKey(attr)) { - Pair prev_buffers = var_buffers_.get(attr); + if (buffers_.containsKey(attr)) { + Pair prev_buffers = buffers_.get(attr); prev_buffers.getFirst().close(); prev_buffers.getSecond().close(); } @@ -765,13 +771,13 @@ public synchronized Query setBuffer( new Pair<>(offsets_array_size, values_array_size); // Close previous buffers if they exist for this attribute - if (var_buffers_.containsKey(attr)) { - Pair prev_buffers = var_buffers_.get(attr); + if (buffers_.containsKey(attr)) { + Pair prev_buffers = buffers_.get(attr); prev_buffers.getFirst().close(); prev_buffers.getSecond().close(); } - var_buffers_.put(attr, new Pair<>(offsets, buffer)); + buffers_.put(attr, new Pair<>(offsets, buffer)); buffer_sizes_.put(attr, buffer_sizes); ctx.handleError( @@ -795,13 +801,13 @@ private Query setBufferSizeUnsafe(String attribute, long offsetSize, long buffer public synchronized Query setBufferByteSize(String attribute, Long offsetSize, Long bufferSize) throws TileDBError { - if (!var_buffers_.containsKey(attribute)) { + if (!buffers_.containsKey(attribute)) { throw new TileDBError("Query var attribute buffer does not exist: " + attribute); } if (offsetSize <= 0 || bufferSize <= 0) { throw new TileDBError("Number of buffer bytes must be >= 1"); } - Pair varBuffers = var_buffers_.get(attribute); + Pair varBuffers = buffers_.get(attribute); NativeArray offsetBuffer = varBuffers.getFirst(); Long offsetNBytes = offsetBuffer.getNBytes(); NativeArray buffer = varBuffers.getSecond(); @@ -831,7 +837,7 @@ public synchronized Query setBufferByteSize(String attribute, Long bufferSize) if (bufferSize <= 0) { throw new TileDBError("Number of buffer bytes must be >= 1"); } - NativeArray buffer = buffers_.get(attribute); + NativeArray buffer = buffers_.get(attribute).getSecond(); Long bufferNBytes = buffer.getNBytes(); if (bufferSize > bufferNBytes) { throw new TileDBError( @@ -851,7 +857,7 @@ public synchronized Query setBufferElements(String attribute, Integer bufferElem if (bufferElements <= 0) { throw new TileDBError("Number of buffer elements must be >= 1"); } - NativeArray buffer = buffers_.get(attribute); + NativeArray buffer = buffers_.get(attribute).getSecond(); Integer bufferSize = buffer.getSize(); if (bufferElements > bufferSize) { throw new TileDBError( @@ -865,13 +871,13 @@ public synchronized Query setBufferElements(String attribute, Integer bufferElem public synchronized Query setBufferElements( String attribute, Integer offsetElements, Integer bufferElements) throws TileDBError { - if (!var_buffers_.containsKey(attribute)) { + if (!buffers_.containsKey(attribute)) { throw new TileDBError("Query var attribute buffer does not exist: " + attribute); } if (offsetElements <= 0 || bufferElements <= 0) { throw new TileDBError("Number of buffer elements must be >= 1"); } - Pair varBuffers = var_buffers_.get(attribute); + Pair varBuffers = buffers_.get(attribute); NativeArray offsetBuffer = varBuffers.getFirst(); Integer offsetSize = offsetBuffer.getSize(); NativeArray buffer = varBuffers.getSecond(); @@ -928,28 +934,32 @@ public Object getCoordinates() throws TileDBError { */ public HashMap> resultBufferElements() throws TileDBError { HashMap> result = new HashMap>(); - for (Map.Entry entry : buffers_.entrySet()) { - String name = entry.getKey(); - NativeArray val_buffer = entry.getValue(); - BigInteger val_nbytes = buffer_sizes_.get(name).getSecond().getitem(0); - Long nelements = - val_nbytes.divide(BigInteger.valueOf(val_buffer.getNativeTypeSize())).longValue(); - result.put(name, new Pair<>(0l, nelements)); - } - for (Map.Entry> entry : var_buffers_.entrySet()) { + for (Map.Entry> entry : buffers_.entrySet()) { String name = entry.getKey(); - Pair buffer_size = buffer_sizes_.get(name); - NativeArray off_buffer = entry.getValue().getFirst(); - BigInteger off_nbytes = buffer_size.getFirst().getitem(0); - Long off_nelements = - off_nbytes.divide(BigInteger.valueOf(off_buffer.getNativeTypeSize())).longValue(); - - NativeArray val_buffer = entry.getValue().getSecond(); - BigInteger val_nbytes = buffer_size.getSecond().getitem(0); - Long val_nelements = - val_nbytes.divide(BigInteger.valueOf(val_buffer.getNativeTypeSize())).longValue(); - result.put(name, new Pair(off_nelements, val_nelements)); + // Fixed-sized + if (entry.getValue().getFirst() == null) { + NativeArray val_buffer = entry.getValue().getSecond(); + BigInteger val_nbytes = buffer_sizes_.get(name).getSecond().getitem(0); + Long nelements = + val_nbytes.divide(BigInteger.valueOf(val_buffer.getNativeTypeSize())).longValue(); + result.put(name, new Pair<>(0l, nelements)); + } + // Var-sized + else { + Pair buffer_size = buffer_sizes_.get(name); + + NativeArray off_buffer = entry.getValue().getFirst(); + BigInteger off_nbytes = buffer_size.getFirst().getitem(0); + Long off_nelements = + off_nbytes.divide(BigInteger.valueOf(off_buffer.getNativeTypeSize())).longValue(); + + NativeArray val_buffer = entry.getValue().getSecond(); + BigInteger val_nbytes = buffer_size.getSecond().getitem(0); + Long val_nelements = + val_nbytes.divide(BigInteger.valueOf(val_buffer.getNativeTypeSize())).longValue(); + result.put(name, new Pair(off_nelements, val_nelements)); + } } return result; } @@ -968,12 +978,11 @@ public HashMap> resultBufferElements() throws TileDBErr */ public HashMap> resultBufferSizes() throws TileDBError { HashMap> result = new HashMap>(); - for (Map.Entry entry : buffers_.entrySet()) { - String name = entry.getKey(); + for (String name : buffers_.keySet()) { BigInteger val_nbytes = buffer_sizes_.get(name).getSecond().getitem(0); result.put(name, new Pair<>(0l, val_nbytes.longValue())); } - for (Map.Entry> entry : var_buffers_.entrySet()) { + for (Map.Entry> entry : buffers_.entrySet()) { String name = entry.getKey(); Pair buffer_size = buffer_sizes_.get(name); @@ -987,15 +996,15 @@ public HashMap> resultBufferSizes() throws TileDBError /** Clears all attribute buffers. */ public synchronized void resetBuffers() { - for (NativeArray buffer : buffers_.values()) { - buffer.close(); + for (Pair buffer : buffers_.values()) { + buffer.getSecond().close(); } buffers_.clear(); - for (Pair var_buffer : var_buffers_.values()) { + for (Pair var_buffer : buffers_.values()) { var_buffer.getFirst().close(); var_buffer.getSecond().close(); } - var_buffers_.clear(); + buffers_.clear(); for (Pair size_pair : buffer_sizes_.values()) { size_pair.getFirst().delete(); size_pair.getSecond().delete(); @@ -1026,7 +1035,7 @@ public Query resetBufferSizes() { */ public Object getBuffer(String attr) throws TileDBError { if (buffers_.containsKey(attr)) { - NativeArray buffer = buffers_.get(attr); + NativeArray buffer = buffers_.get(attr).getSecond(); Integer nelements = (buffer_sizes_ .get(attr) @@ -1035,8 +1044,8 @@ public Object getBuffer(String attr) throws TileDBError { .divide(BigInteger.valueOf(buffer.getNativeTypeSize()))) .intValue(); return buffer.toJavaArray(nelements); - } else if (var_buffers_.containsKey(attr)) { - NativeArray buffer = var_buffers_.get(attr).getSecond(); + } else if (buffers_.containsKey(attr)) { + NativeArray buffer = buffers_.get(attr).getSecond(); Integer nelements = (buffer_sizes_ .get(attr) @@ -1070,10 +1079,10 @@ public Pair getByteBuffer(String attr) throws TileDBErro * @throws TileDBError A TileDB exception */ public long[] getVarBuffer(String attr) throws TileDBError { - if (!var_buffers_.containsKey(attr)) { + if (!buffers_.containsKey(attr)) { throw new TileDBError("Query variable attribute buffer does not exist: " + attr); } - NativeArray buffer = var_buffers_.get(attr).getFirst(); + NativeArray buffer = buffers_.get(attr).getFirst(); Integer nelements = (buffer_sizes_ .get(attr) @@ -1122,12 +1131,9 @@ public synchronized void close() { size_pair.getFirst().delete(); size_pair.getSecond().delete(); } - for (NativeArray buffer : buffers_.values()) { - buffer.close(); - } - for (Pair var_buffer : var_buffers_.values()) { - var_buffer.getFirst().close(); - var_buffer.getSecond().close(); + for (Pair buffer : buffers_.values()) { + if (buffer.getFirst() != null) buffer.getFirst().close(); + if (buffer.getSecond() != null) buffer.getSecond().close(); } if (subarray != null) { subarray.close(); From c505dd073cfd09739fbbd7653be0df36fe7b8aad Mon Sep 17 00:00:00 2001 From: gsvic Date: Tue, 14 Jul 2020 21:25:04 +0300 Subject: [PATCH 5/5] Throw an exception if the order of the ByteBuffer is not correct --- src/main/java/io/tiledb/java/api/Query.java | 12 ++--- .../java/io/tiledb/java/api/QueryTest.java | 54 ++----------------- 2 files changed, 9 insertions(+), 57 deletions(-) diff --git a/src/main/java/io/tiledb/java/api/Query.java b/src/main/java/io/tiledb/java/api/Query.java index 76308765..ed9ff23d 100644 --- a/src/main/java/io/tiledb/java/api/Query.java +++ b/src/main/java/io/tiledb/java/api/Query.java @@ -526,7 +526,8 @@ public synchronized Query setBuffer(String attr, long bufferElements) throws Til int size = Util.castLongToInt(bufferElements * dt.getNativeSize()); - ByteBuffer buffer = ByteBuffer.allocateDirect(size); + ByteBuffer buffer = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder()); + ; this.setBuffer(attr, buffer); @@ -551,14 +552,9 @@ public synchronized Query setBuffer(String attr, ByteBuffer buffer) throws TileD "The ByteBuffer provided is not direct. Please provide a direct buffer (ByteBuffer.allocateDirect(...))"); } - if (!buffer.order().equals(ByteOrder.nativeOrder()) && buffer.position() > 0) { - throw new TileDBError( - "The order of the data ByteBuffer should be the same as the native order (ByteOrder.nativeOrder()) before values are inserted."); - } - if (!buffer.order().equals(ByteOrder.nativeOrder())) { - // TODO: Add a logger component to Query class and a WARN here - buffer.order(ByteOrder.nativeOrder()); + throw new TileDBError( + "The order of the data ByteBuffer should be the same as the native order (ByteOrder.nativeOrder())."); } this.byteBuffers_.put(attr, new Pair<>(null, buffer)); diff --git a/src/test/java/io/tiledb/java/api/QueryTest.java b/src/test/java/io/tiledb/java/api/QueryTest.java index 7be866b2..57a83e44 100644 --- a/src/test/java/io/tiledb/java/api/QueryTest.java +++ b/src/test/java/io/tiledb/java/api/QueryTest.java @@ -356,8 +356,8 @@ public void queryTestNIOReadArrayArbitrarySize() throws Exception { Query query = new Query(array, TILEDB_READ); int bufferSize = 4; - query.setBuffer("rows", ByteBuffer.allocateDirect(10)); - query.setBuffer("cols", ByteBuffer.allocateDirect(10)); + query.setBuffer("rows", ByteBuffer.allocateDirect(10).order(ByteOrder.nativeOrder())); + query.setBuffer("cols", ByteBuffer.allocateDirect(10).order(ByteOrder.nativeOrder())); ByteBuffer d1 = query.getByteBuffer("rows").getSecond(); ByteBuffer d2 = query.getByteBuffer("cols").getSecond(); @@ -444,7 +444,7 @@ public void arrayReadTest() throws Exception { } } - @Test + @Test(expected = TileDBError.class) public void arrayReadTestCustomBufferWithDifferentOrder() throws Exception { arrayCreate(); arrayWrite(); @@ -464,49 +464,7 @@ public void arrayReadTestCustomBufferWithDifferentOrder() throws Exception { ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN; - query - .setBuffer("rows", ByteBuffer.allocateDirect(3 * 4).order(order)) - .setBuffer("cols", ByteBuffer.allocateDirect(3 * 4).order(order)) - .setBuffer("a1", ByteBuffer.allocateDirect(3).order(order)) - .setBuffer("a2", ByteBuffer.allocateDirect(6 * 4).order(order)); - - ByteBuffer dim1Buffer = query.getByteBuffer("rows").getSecond(); - ByteBuffer dim2Buffer = query.getByteBuffer("cols").getSecond(); - ByteBuffer a1Buffer = query.getByteBuffer("a1").getSecond(); - ByteBuffer a2Buffer = query.getByteBuffer("a2").getSecond(); - - // Submit query - query.submit(); - - int[] dim1 = new int[3]; - int[] dim2 = new int[3]; - byte[] a1 = new byte[3]; - float[] a2 = new float[6]; - - int idx = 0; - while (dim1Buffer.hasRemaining()) { - dim1[idx++] = dim1Buffer.getInt(); - } - - idx = 0; - while (dim2Buffer.hasRemaining()) { - dim2[idx++] = dim2Buffer.getInt(); - } - - idx = 0; - while (a1Buffer.hasRemaining()) { - a1[idx++] = a1Buffer.get(); - } - - idx = 0; - while (a2Buffer.hasRemaining()) { - a2[idx++] = a2Buffer.getFloat(); - } - - Assert.assertArrayEquals(new int[] {1, 1, 1}, dim1); - Assert.assertArrayEquals(new int[] {2, 3, 4}, dim2); - Assert.assertArrayEquals(new byte[] {'b', 'c', 'd'}, a1); - Assert.assertArrayEquals(new float[] {1.1f, 1.2f, 2.1f, 2.2f, 3.1f, 3.2f}, a2, 0.01f); + query.setBuffer("rows", ByteBuffer.allocateDirect(3 * 4).order(order)); } } @@ -528,7 +486,7 @@ public void queryTestNIOGetByteBuffer() throws Exception { Assert.assertEquals(query.getByteBuffer("rows").getSecond().order(), ByteOrder.nativeOrder()); } - @Test() + @Test(expected = TileDBError.class) public void queryTestNIOGetByteBuffeErrors() throws Exception { arrayCreate(); arrayWrite(); @@ -554,8 +512,6 @@ public void queryTestNIOGetByteBuffeErrors() throws Exception { // The Byte Order should be automatically changed to the native order query.setBuffer("rows", ByteBuffer.allocateDirect(bufferSize).order(order)); - ByteBuffer b = query.getByteBuffer("rows").getSecond(); - Assert.assertEquals(b.order(), ByteOrder.nativeOrder()); } @Test()