*/
struct S3JniNioArgs {
jobject jBuf; /* input - ByteBuffer */
- jint iBegin; /* input - byte offset */
- jint iN; /* input - byte count to bind */
+ jint iOffset; /* input - byte offset */
+ jint iHowMany; /* input - byte count to bind/read/write */
jint nBuf; /* output - jBuf's buffer size */
void * p; /* output - jBuf's buffer memory */
- const void * pStart; /* output - offset of p to bind */
- int iOutLen; /* output - number of bytes from pStart to bind */
+ const void * pStart; /* output - offset of p to bind/read/write */
+ int nOut; /* output - number of bytes from pStart to bind/read/write */
};
typedef struct S3JniNioArgs S3JniNioArgs;
static const S3JniNioArgs S3JniNioArgs_empty = {
0,0,0,0,0,0,0
};
-/**
- Internal helper for sqlite3_bind_nio_buffer() and
- sqlite3_result_nio_buffer(). Populates pArgs and returns 0 on
- success, non-0 if the operation should fail. The caller is
- required to check for SJG.g.cByteBuffer!=0 before calling
- this and reporting it in a way appropriate for that routine.
- This function may assert() that SJG.g.cByteBuffer is not 0.
-
- The (jBuffer, iBegin, iN) arguments are the (ByteBuffer, offset,
- length) arguments to the bind/result method.
+/*
+** Internal helper for sqlite3_bind_nio_buffer() and
+** sqlite3_result_nio_buffer(). Populates pArgs and returns 0 on
+** success, non-0 if the operation should fail. The caller is required
+** to check for SJG.g.cByteBuffer!=0 before calling this and reporting
+** it in a way appropriate for that routine. This function may
+** assert() that SJG.g.cByteBuffer is not 0.
+**
+** The (jBuffer, iOffset, iN) arguments are the (ByteBuffer, offset,
+** length) arguments to the bind/result method.
+**
+** Returns 0 if everything looks to be in order, else some SQLITE_...
+** result code
*/
static int s3jni_setup_nio_args(
JNIEnv *env, S3JniNioArgs * pArgs,
- jobject jBuffer, jint iBegin, jint iN
+ jobject jBuffer, jint iOffset, jint iN
){
jlong iEnd = 0;
*pArgs = S3JniNioArgs_empty;
pArgs->jBuf = jBuffer;
- pArgs->iBegin = iBegin;
- pArgs->iN = iN;
+ pArgs->iOffset = iOffset;
+ pArgs->iHowMany = iN;
assert( SJG.g.cByteBuffer );
- if( pArgs->iBegin<0 ){
- return SQLITE_MISUSE;
+ if( pArgs->iOffset<0 ){
+ return SQLITE_ERROR
+ /* SQLITE_MISUSE would arguably fit better but we use
+ SQLITE_ERROR for consistency with the code documented for a
+ negative target blob offset in sqlite3_blob_read/write(). */;
}
s3jni_get_nio_buffer(pArgs->jBuf, &pArgs->p, &pArgs->nBuf);
if( !pArgs->p ){
return SQLITE_MISUSE;
- }else if( pArgs->iBegin>=pArgs->nBuf ){
+ }else if( pArgs->iOffset>=pArgs->nBuf ){
pArgs->pStart = 0;
- pArgs->iOutLen = 0;
+ pArgs->nOut = 0;
return 0;
}
assert( pArgs->nBuf > 0 );
- assert( pArgs->iBegin < pArgs->nBuf );
- iEnd = pArgs->iN<0 ? pArgs->nBuf - pArgs->iBegin : pArgs->iBegin + pArgs->iN;
- if( iEnd>(jlong)pArgs->nBuf ) iEnd = pArgs->nBuf - pArgs->iBegin;
- if( iEnd - pArgs->iBegin > (jlong)SQLITE_MAX_LENGTH ){
+ assert( pArgs->iOffset < pArgs->nBuf );
+ iEnd = pArgs->iHowMany<0
+ ? pArgs->nBuf - pArgs->iOffset
+ : pArgs->iOffset + pArgs->iHowMany;
+ if( iEnd>(jlong)pArgs->nBuf ) iEnd = pArgs->nBuf - pArgs->iOffset;
+ if( iEnd - pArgs->iOffset > (jlong)SQLITE_MAX_LENGTH ){
return SQLITE_TOOBIG;
}
- assert( pArgs->iBegin >= 0 );
- assert( iEnd > pArgs->iBegin );
- pArgs->pStart = pArgs->p + pArgs->iBegin;
- pArgs->iOutLen = (int)(iEnd - pArgs->iBegin);
- assert( pArgs->iOutLen > 0 );
+ assert( pArgs->iOffset >= 0 );
+ assert( iEnd > pArgs->iOffset );
+ pArgs->pStart = pArgs->p + pArgs->iOffset;
+ pArgs->nOut = (int)(iEnd - pArgs->iOffset);
+ assert( pArgs->nOut > 0 );
return 0;
}
S3JniApi(sqlite3_bind_nio_buffer(),jint,1bind_1nio_1buffer)(
JniArgsEnvClass, jobject jpStmt, jint ndx, jobject jBuffer,
- jint iBegin, jint iN
+ jint iOffset, jint iN
){
sqlite3_stmt * pStmt = PtrGet_sqlite3_stmt(jpStmt);
S3JniNioArgs args;
int rc;
if( !pStmt || !SJG.g.cByteBuffer ) return SQLITE_MISUSE;
- rc = s3jni_setup_nio_args(env, &args, jBuffer, iBegin, iN);
+ rc = s3jni_setup_nio_args(env, &args, jBuffer, iOffset, iN);
if(rc){
return rc;
- }else if( !args.pStart || !args.iOutLen ){
+ }else if( !args.pStart || !args.nOut ){
return sqlite3_bind_null(pStmt, ndx);
}
- assert( args.iOutLen>0 );
+ assert( args.nOut>0 );
assert( args.nBuf > 0 );
assert( args.pStart != 0 );
- assert( (args.pStart + args.iOutLen) <= (args.p + args.nBuf) );
+ assert( (args.pStart + args.nOut) <= (args.p + args.nBuf) );
return sqlite3_bind_blob( pStmt, (int)ndx, args.pStart,
- args.iOutLen, SQLITE_TRANSIENT );
+ args.nOut, SQLITE_TRANSIENT );
}
S3JniApi(sqlite3_bind_double(),jint,1bind_1double)(
return (jint)rc;
}
+S3JniApi(sqlite3_blob_write_nio_buffer(),jint,1blob_1write_1nio_1buffer)(
+ JniArgsEnvClass, jlong jpBlob, jint iSrcOff, jobject jBB, jint iTgtOff, jint iHowMany
+){
+ sqlite3_blob * const b = LongPtrGet_sqlite3_blob(jpBlob);
+ S3JniNioArgs args;
+ int rc;
+ if( !b || !SJG.g.cByteBuffer ){
+ return SQLITE_MISUSE;
+ }else if( iTgtOff<0 || iSrcOff<0 ){
+ return SQLITE_ERROR
+ /* for consistency with underlying sqlite3_blob_write() */;
+ }else if( 0==iHowMany ){
+ return 0;
+ }
+ rc = s3jni_setup_nio_args(env, &args, jBB, iTgtOff, iHowMany);
+ if(rc){
+ return rc;
+ }else if( !args.pStart || !args.nOut ){
+ return 0;
+ }
+ assert( args.nOut>0 );
+ assert( args.nBuf > 0 );
+ assert( args.pStart != 0 );
+ assert( (args.pStart + args.nOut) <= (args.p + args.nBuf) );
+ return sqlite3_blob_write( b, args.pStart, (int)args.nOut, iSrcOff );
+}
+
/* Central C-to-Java busy handler proxy. */
static int s3jni_busy_handler(void* pState, int n){
S3JniDb * const ps = (S3JniDb *)pState;
return rv;
}
-S3JniApi(sqlite3_value_nio_buffer(),jobject,1column_1nio_1buffer)(
+S3JniApi(sqlite3_column_nio_buffer(),jobject,1column_1nio_1buffer)(
JniArgsEnvClass, jobject jStmt, jint ndx
){
sqlite3_stmt * const stmt = PtrGet_sqlite3_stmt(jStmt);
S3JniApi(sqlite3_result_nio_buffer(),void,1result_1nio_1buffer)(
JniArgsEnvClass, jobject jpCtx, jobject jBuffer,
- jint iBegin, jint iN
+ jint iOffset, jint iN
){
sqlite3_context * pCx = PtrGet_sqlite3_context(jpCtx);
int rc;
);
return;
}
- rc = s3jni_setup_nio_args(env, &args, jBuffer, iBegin, iN);
+ rc = s3jni_setup_nio_args(env, &args, jBuffer, iOffset, iN);
if(rc){
- if( iBegin<0 ){
+ if( iOffset<0 ){
sqlite3_result_error(pCx, "Start index may not be negative.", -1);
}else if( SQLITE_TOOBIG==rc ){
sqlite3_result_error_toobig(pCx);
pCx, "Invalid arguments to sqlite3_result_nio_buffer().", -1
);
}
- }else if( !args.pStart || !args.iOutLen ){
+ }else if( !args.pStart || !args.nOut ){
sqlite3_result_null(pCx);
}else{
- sqlite3_result_blob(pCx, args.pStart, args.iOutLen, SQLITE_TRANSIENT);
+ sqlite3_result_blob(pCx, args.pStart, args.nOut, SQLITE_TRANSIENT);
}
}
JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1write
(JNIEnv *, jclass, jlong, jbyteArray, jint);
+/*
+ * Class: org_sqlite_jni_capi_CApi
+ * Method: sqlite3_blob_write_nio_buffer
+ * Signature: (JILjava/nio/ByteBuffer;II)I
+ */
+JNIEXPORT jint JNICALL Java_org_sqlite_jni_capi_CApi_sqlite3_1blob_1write_1nio_1buffer
+ (JNIEnv *, jclass, jlong, jint, jobject, jint, jint);
+
/*
* Class: org_sqlite_jni_capi_CApi
* Method: sqlite3_busy_handler
<p>This routine returns false without side effects if the current
JNIEnv is not cached, else returns true, but this information is
primarily for testing of the JNI bindings and is not information
- which client-level code can use to make any informed decisions.
+ which client-level code can use to make any informed
+ decisions. Its return type and semantics are not considered
+ stable and may change at any time.
*/
public static native boolean sqlite3_java_uncache_thread();
/**
- Returns true if this JVM has JNI-level support for direct memory
- access using java.nio.ByteBuffer, else returns false.
+ Returns true if this JVM has JNI-level support for C-level direct
+ memory access using java.nio.ByteBuffer, else returns false.
*/
public static native boolean sqlite3_jni_supports_nio();
return sqlite3_blob_write(b.getNativePointer(), bytes, iOffset);
}
+
+ /**
+ An internal level of indirection in order to avoid having
+ overloaded names of sqlite3_blob_write() in the C API, as the
+ resulting mangled names are unwieldy. The public face of this
+ method is the sqlite3_blob_write() overload which takes a
+ java.nio.ByteBuffer.
+ */
+ private static native int sqlite3_blob_write_nio_buffer(
+ @NotNull long ptrToBlob, int tgtOffset,
+ @NotNull java.nio.ByteBuffer src,
+ int srcOffset, int howMany
+ );
+
+ /**
+ Writes howMany bytes of memory from offset srcOffset of the src
+ buffer at position tgtOffset of b.
+
+ If howMany is negative then it's equivalent to the number of
+ bytes remaining starting at srcOffset. If the computed input
+ slice exceeds src's bounds, the slice is silently truncated.
+ */
+ public static int sqlite3_blob_write(
+ @NotNull sqlite3_blob b, int tgtOffset,
+ @NotNull java.nio.ByteBuffer src,
+ int srcOffset, int howMany
+ ){
+ return sqlite3_blob_write_nio_buffer(b.getNativePointer(), tgtOffset,
+ src, srcOffset, howMany);
+ }
+
+ /**
+ Convenience overload which writes all of src to the given offset
+ of b.
+ */
+ public static int sqlite3_blob_write(
+ @NotNull sqlite3_blob b, int tgtOffset,
+ @NotNull java.nio.ByteBuffer src
+ ){
+ return sqlite3_blob_write_nio_buffer(b.getNativePointer(), tgtOffset,
+ src, 0, -1);
+ }
+
private static native int sqlite3_busy_handler(
@NotNull long ptrToDb, @Nullable BusyHandlerCallback handler
);
<ul>
- <li>text is null: translates to a call to sqlite3_result_null()</li>
+ <li>text is null: translates to a call to {@link
+ #sqlite3_result_null}</li>
<li>text is too large: translates to a call to
{@link #sqlite3_result_error_toobig}</li>
/** Sets the current value. */
public final void set(byte[] v){value = v;}
}
+
+ /**
+ Output pointer for use with native routines which return
+ blobs via java.nio.ByteBuffer.
+
+ See {@link org.sqlite.jni.capi.CApi#sqlite3_jni_supports_nio}
+ */
+ public static final class ByteBuffer {
+ /**
+ This is public for ease of use. Accessors are provided for
+ consistency with the higher-level types.
+ */
+ public java.nio.ByteBuffer value;
+ /** Initializes with the value null. */
+ public ByteBuffer(){this(null);}
+ /** Initializes with the value v. */
+ public ByteBuffer(java.nio.ByteBuffer v){value = v;}
+ /** Returns the current value. */
+ public final java.nio.ByteBuffer get(){return value;}
+ /** Sets the current value. */
+ public final void set(java.nio.ByteBuffer v){value = v;}
+ }
}
final int expectTotal = buf.get(1) + buf.get(2) + buf.get(3);
sqlite3_stmt stmt = prepare(db, "INSERT INTO t(a) VALUES(?);");
- affirm( SQLITE_MISUSE == sqlite3_bind_blob(stmt, 1, buf, -1, 0) );
+ affirm( SQLITE_ERROR == sqlite3_bind_blob(stmt, 1, buf, -1, 0),
+ "Buffer offset may not be negative." );
affirm( 0 == sqlite3_bind_blob(stmt, 1, buf, 1, 3) );
affirm( SQLITE_DONE == sqlite3_step(stmt) );
sqlite3_finalize(stmt);
affirm( 100==tgt[0] && 101==tgt[1] && 102==tgt[2], "DEF" );
rc = sqlite3_blob_close(b);
affirm( 0==rc );
+
+ if( !sqlite3_jni_supports_nio() ){
+ outln("WARNING: skipping tests for ByteBuffer-using sqlite3_blob APIs ",
+ "because this platform lacks that support.");
+ sqlite3_close_v2(db);
+ return;
+ }
+ /* Sanity checks for the java.nio.ByteBuffer-taking overloads of
+ sqlite3_blob_read/write(). */
+ execSql(db, "UPDATE t SET a=zeroblob(10)");
+ b = sqlite3_blob_open(db, "main", "t", "a", 1, 1);
+ affirm( null!=b );
+ java.nio.ByteBuffer bb = java.nio.ByteBuffer.allocateDirect(10);
+ for( byte i = 0; i < 10; ++i ){
+ bb.put((int)i, (byte)(48+i & 0xff));
+ }
+ rc = sqlite3_blob_write(b, 1, bb);
+ affirm( rc==SQLITE_ERROR, "Because b length < (offset 1 + bb length)" );
+ rc = sqlite3_blob_write(b, -1, bb);
+ affirm( rc==SQLITE_ERROR, "Target offset may not be negative" );
+ rc = sqlite3_blob_write(b, 0, bb, -1, -1);
+ affirm( rc==SQLITE_ERROR, "Source offset may not be negative" );
+ rc = sqlite3_blob_write(b, 1, bb, 1, 8);
+ affirm( rc==0 );
+ // b's contents: 0 49 50 51 52 53 54 55 56 0
+ // ascii: 0 '1' '2' '3' '4' '5' '6' '7' '8' 0
+ byte br[] = new byte[10];
+ rc = sqlite3_blob_read( b, br, 0 );
+ sqlite3_blob_close(b);
+ affirm( rc==0 );
+ affirm( 0==br[0] );
+ affirm( 0==br[9] );
+ for( int i = 1; i < 9; ++i ){
+ affirm( br[i] == 48 + i );
+ }
sqlite3_close_v2(db);
}
-C JNI:\sadd\ssqlite3_column_nio_buffer()\sand\ssqlite3_value_nio_buffer()\susing\san\sonly-slightly\sroundabout\sapproach\sto\screating\sproperly-sized\sByteBuffer\sobjects.
-D 2023-11-13T23:11:10.170
+C JNI:\sadd\ssqlite3_blob_write()\soverload\swhich\saccepts\sa\sjava.nio.ByteBuffer.\sCleanups\sin\sadjacent\scode.
+D 2023-11-14T01:33:15.332
F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1
F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea
F LICENSE.md df5091916dbb40e6e9686186587125e1b2ff51f022cc334e886c19a0e9982724
F ext/jni/GNUmakefile f2f3a31923293659b95225e932a286af1f2287d75bf88ad6c0fd1b9d9cd020d4
F ext/jni/README.md ef9ac115e97704ea995d743b4a8334e23c659e5534c3b64065a5405256d5f2f4
F ext/jni/jar-dist.make 030aaa4ae71dd86e4ec5e7c1e6cd86f9dfa47c4592c070d2e35157e42498e1fa
-F ext/jni/src/c/sqlite3-jni.c c63250298bf0bdc335704d877f559dcdefaa041ba0556022b13599d43badb822
-F ext/jni/src/c/sqlite3-jni.h bd95cd17bfe2c7bd5e865a785bc5ed99591f1a1581c9b1a1b9ba7d65fb41d4cc
+F ext/jni/src/c/sqlite3-jni.c 0668675c6ec44a4109035d7236233867cd3bfc63f82bbb5a1c679ab412f795ba
+F ext/jni/src/c/sqlite3-jni.h a7c4b87b200d6eb2745867c7d955941c56bc035ddee79b2c7382822565aa17c2
F ext/jni/src/org/sqlite/jni/annotation/NotNull.java 02091a8112e33389f1c160f506cd413168c8dfacbeda608a4946c6e3557b7d5a
F ext/jni/src/org/sqlite/jni/annotation/Nullable.java 0b1879852707f752512d4db9d7edd0d8db2f0c2612316ce1c832715e012ff6ba
F ext/jni/src/org/sqlite/jni/annotation/package-info.java 977b374aed9d5853cbf3438ba3b0940abfa2ea4574f702a2448ee143b98ac3ca
F ext/jni/src/org/sqlite/jni/capi/AuthorizerCallback.java c045a5b47e02bb5f1af91973814a905f12048c428a3504fbc5266d1c1be3de5a
F ext/jni/src/org/sqlite/jni/capi/AutoExtensionCallback.java 74cc4998a73d6563542ecb90804a3c4f4e828cb4bd69e61226d1a51f4646e759
F ext/jni/src/org/sqlite/jni/capi/BusyHandlerCallback.java 7b8e19810c42b0ad21a04b5d8c804b32ee5905d137148703f16a75b612c380ca
-F ext/jni/src/org/sqlite/jni/capi/CApi.java bf81e122cff8a6d88b5185e57e38f5e2c3387a4e84ee6732aff234da6966d21f
+F ext/jni/src/org/sqlite/jni/capi/CApi.java d8424b0fb29b6c2bd0753eca5a026c007e967a093421094207b32bb147123699
F ext/jni/src/org/sqlite/jni/capi/CallbackProxy.java 57e2d275dcebe690b1fc1f3d34eb96879b2d7039bce30b563aee547bf45d8a8b
F ext/jni/src/org/sqlite/jni/capi/CollationCallback.java e29bcfc540fdd343e2f5cca4d27235113f2886acb13380686756d5cabdfd065a
F ext/jni/src/org/sqlite/jni/capi/CollationNeededCallback.java 5bfa226a8e7a92e804fd52d6e42b4c7b875fa7a94f8e2c330af8cc244a8920ab
F ext/jni/src/org/sqlite/jni/capi/ConfigLogCallback.java b995ca412f59b631803b93aa5b3684fce62e335d1e123207084c054abfd488d4
F ext/jni/src/org/sqlite/jni/capi/ConfigSqllogCallback.java 701f2e4d8bdeb27cfbeeb56315d15b13d8752b0fdbca705f31bd4366c58d8a33
F ext/jni/src/org/sqlite/jni/capi/NativePointerHolder.java b7036dcb1ef1b39f1f36ac605dde0ff1a24a9a01ade6aa1a605039443e089a61
-F ext/jni/src/org/sqlite/jni/capi/OutputPointer.java 68f60aec7aeb5cd4e5fb83449037f668c63cb99f682ee1036cc226d0cbd909b9
+F ext/jni/src/org/sqlite/jni/capi/OutputPointer.java 246b0e66c4603f41c567105a21189d138aaf8c58203ecd4928802333da553e7c
F ext/jni/src/org/sqlite/jni/capi/PrepareMultiCallback.java aca8f9fa72e3b6602bc9a7dd3ae9f5b2808103fbbee9b2749dc96c19cdc261a1
F ext/jni/src/org/sqlite/jni/capi/PreupdateHookCallback.java efcf57545c5e282d1dd332fa63329b3b218d98f356ef107a9dbe3979be82213a
F ext/jni/src/org/sqlite/jni/capi/ProgressHandlerCallback.java 01bc0c238eed2d5f93c73522cb7849a445cc9098c2ed1e78248fa20ed1cfde5b
F ext/jni/src/org/sqlite/jni/capi/SQLTester.java 09bee15aa0eedac68d767ae21d9a6a62a31ade59182a3ccbf036d6463d9e30b1
F ext/jni/src/org/sqlite/jni/capi/ScalarFunction.java 93b9700fca4c68075ccab12fe0fbbc76c91cafc9f368e835b9bd7cd7732c8615
F ext/jni/src/org/sqlite/jni/capi/TableColumnMetadata.java addf120e0e76e5be1ff2260daa7ce305ff9b5fafd64153a7a28e9d8f000a815f
-F ext/jni/src/org/sqlite/jni/capi/Tester1.java 646b75c3ec454a2daa20fef1c15ed76f24882f8e529ff3749779bc2ece3c2820
+F ext/jni/src/org/sqlite/jni/capi/Tester1.java 738fa19c2688fe22eb856edf2292e846d6804748f00d6b753ecdea627095c5f8
F ext/jni/src/org/sqlite/jni/capi/TraceV2Callback.java 0a25e117a0daae3394a77f24713e36d7b44c67d6e6d30e9e1d56a63442eef723
F ext/jni/src/org/sqlite/jni/capi/UpdateHookCallback.java c8bdf7848e6599115d601bcc9427ff902cb33129b9be32870ac6808e04b6ae56
F ext/jni/src/org/sqlite/jni/capi/ValueHolder.java 22d365746a78c5cd7ae10c39444eb7bbf1a819aad4bb7eb77b1edc47773a3950
F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P 44b4df01ff86841fb85b6295cbada422c6ba8a32a420a2e840e2d607b6c90164
-R 723ebc4fdaf6a9b23550997df97352fc
+P efbc82b218d26b7ca9b881da69d5fd14d22b5211fbd85a835da50e5bfde3d160
+R b363dc4648f62c28510d70ed94844bbc
U stephan
-Z bec7a2465a92db0fb274e1f6df96d01f
+Z 47e30de17d53e7dab348193d2caa8c99
# Remove this line to create a well-formed Fossil manifest.
-efbc82b218d26b7ca9b881da69d5fd14d22b5211fbd85a835da50e5bfde3d160
\ No newline at end of file
+ca32af8542aa2725cc87f54541b19897556f610e4674edf9f22a84e3d4097a82
\ No newline at end of file
projects / thirdparty / sqlite.git / commitdiff
