From: stephan Date: Sun, 3 Sep 2023 14:13:29 +0000 (+0000) Subject: Expose the sqlite3_blob_...() APIs to JNI. X-Git-Tag: version-3.44.0~216^2~9 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=805e8c96b91fb53fc978d5382d51aa993815a78d;p=thirdparty%2Fsqlite.git Expose the sqlite3_blob_...() APIs to JNI. FossilOrigin-Name: 9a9945c405cfe9b6bf399655f498457da66b06c8b92014510ab9fb83fbb1c7d4 --- diff --git a/ext/jni/src/c/sqlite3-jni.c b/ext/jni/src/c/sqlite3-jni.c index 8773a7ed7d..720de5c56f 100644 --- a/ext/jni/src/c/sqlite3-jni.c +++ b/ext/jni/src/c/sqlite3-jni.c @@ -336,6 +336,7 @@ struct S3JniNphOp { static const struct { const S3JniNphOp sqlite3; const S3JniNphOp sqlite3_backup; + const S3JniNphOp sqlite3_blob; const S3JniNphOp sqlite3_context; const S3JniNphOp sqlite3_stmt; const S3JniNphOp sqlite3_value; @@ -343,6 +344,7 @@ static const struct { const S3JniNphOp OutputPointer_Int32; const S3JniNphOp OutputPointer_Int64; const S3JniNphOp OutputPointer_sqlite3; + const S3JniNphOp OutputPointer_sqlite3_blob; const S3JniNphOp OutputPointer_sqlite3_stmt; const S3JniNphOp OutputPointer_sqlite3_value; const S3JniNphOp OutputPointer_String; @@ -363,26 +365,29 @@ static const struct { #define RefO(INDEX, KLAZZ, SIG) MkRef(INDEX, KLAZZ, "value", SIG) RefN(0, "sqlite3"), RefN(1, "sqlite3_backup"), - RefN(2, "sqlite3_context"), - RefN(3, "sqlite3_stmt"), - RefN(4, "sqlite3_value"), - RefO(5, "OutputPointer$Bool", "Z"), - RefO(6, "OutputPointer$Int32", "I"), - RefO(7, "OutputPointer$Int64", "J"), - RefO(8, "OutputPointer$sqlite3", + RefN(2, "sqlite3_blob"), + RefN(3, "sqlite3_context"), + RefN(4, "sqlite3_stmt"), + RefN(5, "sqlite3_value"), + RefO(6, "OutputPointer$Bool", "Z"), + RefO(7, "OutputPointer$Int32", "I"), + RefO(8, "OutputPointer$Int64", "J"), + RefO(9, "OutputPointer$sqlite3", "Lorg/sqlite/jni/sqlite3;"), - RefO(9, "OutputPointer$sqlite3_stmt", + RefO(10, "OutputPointer$sqlite3_blob", + "Lorg/sqlite/jni/sqlite3_blob;"), + RefO(11, "OutputPointer$sqlite3_stmt", "Lorg/sqlite/jni/sqlite3_stmt;"), - RefO(10, "OutputPointer$sqlite3_value", + RefO(12, "OutputPointer$sqlite3_value", "Lorg/sqlite/jni/sqlite3_value;"), - RefO(11, "OutputPointer$String", "Ljava/lang/String;"), + RefO(13, "OutputPointer$String", "Ljava/lang/String;"), #ifdef SQLITE_ENABLE_FTS5 - RefO(12, "OutputPointer$ByteArray", "[B"), - RefN(13, "Fts5Context"), - RefN(14, "Fts5ExtensionApi"), - RefN(15, "fts5_api"), - RefN(16, "fts5_tokenizer"), - RefN(17, "Fts5Tokenizer") + RefO(14, "OutputPointer$ByteArray", "[B"), + RefN(15, "Fts5Context"), + RefN(16, "Fts5ExtensionApi"), + RefN(17, "fts5_api"), + RefN(18, "fts5_tokenizer"), + RefN(19, "Fts5Tokenizer") #endif #undef MkRef #undef RefN @@ -1429,6 +1434,7 @@ static void * NativePointerHolder__get(JNIEnv * env, jobject jNph, #define PtrGet_T(T,OBJ) (T*)NativePointerHolder_get(OBJ, S3JniNph(T)) #define PtrGet_sqlite3(OBJ) PtrGet_T(sqlite3, OBJ) #define PtrGet_sqlite3_backup(OBJ) PtrGet_T(sqlite3_backup, OBJ) +#define PtrGet_sqlite3_blob(OBJ) PtrGet_T(sqlite3_blob, OBJ) #define PtrGet_sqlite3_context(OBJ) PtrGet_T(sqlite3_context, OBJ) #define PtrGet_sqlite3_stmt(OBJ) PtrGet_T(sqlite3_stmt, OBJ) #define PtrGet_sqlite3_value(OBJ) PtrGet_T(sqlite3_value, OBJ) @@ -1591,8 +1597,17 @@ static void OutputPointer_set_obj(JNIEnv * const env, ** v. */ static void OutputPointer_set_sqlite3(JNIEnv * const env, jobject const jOut, - jobject jDb){ - OutputPointer_set_obj(env, S3JniNph(OutputPointer_sqlite3), jOut, jDb); + jobject v){ + OutputPointer_set_obj(env, S3JniNph(OutputPointer_sqlite3), jOut, v); +} + +/* +** Sets the value property of the OutputPointer.sqlite3_blob jOut object to +** v. +*/ +static void OutputPointer_set_sqlite3_blob(JNIEnv * const env, jobject const jOut, + jobject v){ + OutputPointer_set_obj(env, S3JniNph(OutputPointer_sqlite3_blob), jOut, v); } /* @@ -1600,8 +1615,8 @@ static void OutputPointer_set_sqlite3(JNIEnv * const env, jobject const jOut, ** v. */ static void OutputPointer_set_sqlite3_stmt(JNIEnv * const env, jobject const jOut, - jobject jStmt){ - OutputPointer_set_obj(env, S3JniNph(OutputPointer_sqlite3_stmt), jOut, jStmt); + jobject v){ + OutputPointer_set_obj(env, S3JniNph(OutputPointer_sqlite3_stmt), jOut, v); } #ifdef SQLITE_ENABLE_PREUPDATE_HOOK @@ -1610,8 +1625,8 @@ static void OutputPointer_set_sqlite3_stmt(JNIEnv * const env, jobject const jOu ** v. */ static void OutputPointer_set_sqlite3_value(JNIEnv * const env, jobject const jOut, - jobject jValue){ - OutputPointer_set_obj(env, S3JniNph(OutputPointer_sqlite3_value), jOut, jValue); + jobject v){ + OutputPointer_set_obj(env, S3JniNph(OutputPointer_sqlite3_value), jOut, v); } #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ @@ -1704,6 +1719,9 @@ static inline jobject new_java_sqlite3(JNIEnv * const env, sqlite3 *sv){ static inline jobject new_java_sqlite3_backup(JNIEnv * const env, sqlite3_backup *sv){ return NativePointerHolder_new(env, S3JniNph(sqlite3_backup), sv); } +static inline jobject new_java_sqlite3_blob(JNIEnv * const env, sqlite3_blob *sv){ + return NativePointerHolder_new(env, S3JniNph(sqlite3_blob), sv); +} static inline jobject new_java_sqlite3_context(JNIEnv * const env, sqlite3_context *sv){ return NativePointerHolder_new(env, S3JniNph(sqlite3_context), sv); } @@ -2416,6 +2434,76 @@ S3JniApi(sqlite3_bind_zeroblob(),jint,1bind_1zeroblob64)( return (jint)sqlite3_bind_zeroblob(PtrGet_sqlite3_stmt(jpStmt), (int)ndx, (sqlite3_uint64)n); } +S3JniApi(sqlite3_blob_bytes(),jint,1blob_1bytes)( + JniArgsEnvClass, jobject jBlob +){ + return sqlite3_blob_bytes(PtrGet_sqlite3_blob(jBlob)); +} + +S3JniApi(sqlite3_blob_close(),jint,1blob_1close)( + JniArgsEnvClass, jobject jBlob +){ + sqlite3_blob * const b = PtrGet_sqlite3_blob(jBlob); + jint const rc = b ? (jint)sqlite3_blob_close(b) : SQLITE_MISUSE; + if( b ){ + NativePointerHolder_set(S3JniNph(sqlite3_blob), jBlob, 0); + } + return rc; +} + +S3JniApi(sqlite3_blob_open(),jint,1blob_1open)( + JniArgsEnvClass, jobject jDb, jstring jDbName, jstring jTbl, jstring jCol, + jlong jRowId, jint flags, jobject jOut +){ + sqlite3 * const db = PtrGet_sqlite3(jDb); + sqlite3_blob * pBlob = 0; + char * zDbName = 0, * zTableName = 0, * zColumnName = 0; + int rc; + + if( !db || !jDbName || !jTbl || !jCol ) return SQLITE_MISUSE; + zDbName = s3jni_jstring_to_utf8(jDbName,0); + zTableName = zDbName ? s3jni_jstring_to_utf8(jTbl,0) : 0; + zColumnName = zTableName ? s3jni_jstring_to_utf8(jCol,0) : 0; + rc = zColumnName + ? sqlite3_blob_open(db, zDbName, zTableName, zColumnName, + (sqlite3_int64)jRowId, (int)flags, &pBlob) + : SQLITE_NOMEM; + if( 0==rc ){ + jobject rv = new_java_sqlite3_blob(env, pBlob); + if( rv ){ + OutputPointer_set_sqlite3_blob(env, jOut, rv); + }else{ + sqlite3_blob_close(pBlob); + rc = SQLITE_NOMEM; + } + } + sqlite3_free(zDbName); + sqlite3_free(zTableName); + sqlite3_free(zColumnName); + return rc; +} + +S3JniApi(sqlite3_blob_reopen(),jint,1blob_1reopen)( + JniArgsEnvClass, jobject jBlob, jlong iNewRowId +){ + return (jint)sqlite3_blob_reopen(PtrGet_sqlite3_blob(jBlob), + (sqlite3_int64)iNewRowId); +} + +S3JniApi(sqlite3_blob_write(),jint,1blob_1write)( + JniArgsEnvClass, jobject jBlob, jbyteArray jBa, jint iOffset +){ + sqlite3_blob * const b = PtrGet_sqlite3_blob(jBlob); + jbyte * const pBuf = b ? s3jni_jbyteArray_bytes(jBa) : 0; + const jsize nBa = pBuf ? (*env)->GetArrayLength(env, jBa) : 0; + int rc = SQLITE_MISUSE; + if(b && pBuf){ + rc = sqlite3_blob_write( b, pBuf, nBa, (int)iOffset ); + } + s3jni_jbyteArray_release(jBa, pBuf); + return (jint)rc; +} + /* Central C-to-Java busy handler proxy. */ static int s3jni_busy_handler(void* pState, int n){ S3JniDb * const ps = (S3JniDb *)pState; diff --git a/ext/jni/src/c/sqlite3-jni.h b/ext/jni/src/c/sqlite3-jni.h index d000b0a465..91d512205f 100644 --- a/ext/jni/src/c/sqlite3-jni.h +++ b/ext/jni/src/c/sqlite3-jni.h @@ -947,6 +947,46 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1zeroblob JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1zeroblob64 (JNIEnv *, jclass, jobject, jint, jlong); +/* + * Class: org_sqlite_jni_SQLite3Jni + * Method: sqlite3_blob_bytes + * Signature: (Lorg/sqlite/jni/sqlite3_blob;)I + */ +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1bytes + (JNIEnv *, jclass, jobject); + +/* + * Class: org_sqlite_jni_SQLite3Jni + * Method: sqlite3_blob_close + * Signature: (Lorg/sqlite/jni/sqlite3_blob;)I + */ +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1close + (JNIEnv *, jclass, jobject); + +/* + * Class: org_sqlite_jni_SQLite3Jni + * Method: sqlite3_blob_open + * Signature: (Lorg/sqlite/jni/sqlite3;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;JILorg/sqlite/jni/OutputPointer/sqlite3_blob;)I + */ +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1open + (JNIEnv *, jclass, jobject, jstring, jstring, jstring, jlong, jint, jobject); + +/* + * Class: org_sqlite_jni_SQLite3Jni + * Method: sqlite3_blob_reopen + * Signature: (Lorg/sqlite/jni/sqlite3_blob;J)I + */ +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1reopen + (JNIEnv *, jclass, jobject, jlong); + +/* + * Class: org_sqlite_jni_SQLite3Jni + * Method: sqlite3_blob_write + * Signature: (Lorg/sqlite/jni/sqlite3_blob;[BI)I + */ +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1write + (JNIEnv *, jclass, jobject, jbyteArray, jint); + /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_busy_handler diff --git a/ext/jni/src/org/sqlite/jni/OutputPointer.java b/ext/jni/src/org/sqlite/jni/OutputPointer.java index f27d977744..c6e48ed72f 100644 --- a/ext/jni/src/org/sqlite/jni/OutputPointer.java +++ b/ext/jni/src/org/sqlite/jni/OutputPointer.java @@ -64,6 +64,27 @@ public final class OutputPointer { } } + /** + Output pointer for sqlite3_blob_open(). These + pointers can only be set by the JNI layer, not by client-level + code. + */ + public static final class sqlite3_blob { + private org.sqlite.jni.sqlite3_blob value; + /** Initializes with a null value. */ + public sqlite3_blob(){value = null;} + /** Sets the current value to null. */ + public void clear(){value = null;} + /** Returns the current value. */ + public final org.sqlite.jni.sqlite3_blob get(){return value;} + /** Equivalent to calling get() then clear(). */ + public final org.sqlite.jni.sqlite3_blob take(){ + final org.sqlite.jni.sqlite3_blob v = value; + value = null; + return v; + } + } + /** Output pointer for use with routines, such as sqlite3_prepare(), which return a statement handle via an output pointer. These diff --git a/ext/jni/src/org/sqlite/jni/SQLite3Jni.java b/ext/jni/src/org/sqlite/jni/SQLite3Jni.java index 9222c2ad72..407b5dfbd6 100644 --- a/ext/jni/src/org/sqlite/jni/SQLite3Jni.java +++ b/ext/jni/src/org/sqlite/jni/SQLite3Jni.java @@ -342,6 +342,42 @@ public final class SQLite3Jni { @NotNull sqlite3_stmt stmt, int ndx, long n ); + @Canonical + public static native int sqlite3_blob_bytes(@NotNull sqlite3_blob blob); + + @Canonical + public static native int sqlite3_blob_close(@Nullable sqlite3_blob blob); + + @Canonical + public static native int sqlite3_blob_open( + @NotNull sqlite3 db, @NotNull String dbName, + @NotNull String tableName, @NotNull String columnName, + long iRow, int flags, @NotNull OutputPointer.sqlite3_blob out + ); + + /** + Convenience overload. + */ + public static sqlite3_blob sqlite3_blob_open( + @NotNull sqlite3 db, @NotNull String dbName, + @NotNull String tableName, @NotNull String columnName, + long iRow, int flags ){ + final OutputPointer.sqlite3_blob out = new OutputPointer.sqlite3_blob(); + sqlite3_blob_open(db, dbName, tableName, columnName, iRow, flags, out); + return out.take(); + }; + + @Canonical + public static native int sqlite3_blob_reopen( + @NotNull sqlite3_blob out, long newRowId + ); + + @Canonical + public static native int sqlite3_blob_write( + @NotNull sqlite3_blob out, @NotNull byte[] bytes, + int iOffset + ); + /** As for the C-level function of the same name, with a BusyHandlerCallback instance in place of a callback @@ -1557,6 +1593,16 @@ public final class SQLite3Jni { @NotNull sqlite3 db, @Nullable UpdateHookCallback hook ); + /* + Note that: + + void * sqlite3_user_data(sqlite3_context*) + + Is not relevant in the JNI binding, as its feature is replaced by + the ability to pass an object, including any relevant state, to + sqlite3_create_function(). + */ + @Canonical public static native byte[] sqlite3_value_blob(@NotNull sqlite3_value v); diff --git a/ext/jni/src/org/sqlite/jni/Tester1.java b/ext/jni/src/org/sqlite/jni/Tester1.java index d5db8170c7..409418bf60 100644 --- a/ext/jni/src/org/sqlite/jni/Tester1.java +++ b/ext/jni/src/org/sqlite/jni/Tester1.java @@ -1537,6 +1537,33 @@ public class Tester1 implements Runnable { affirm( i!=0, "There's a very slight chance that 0 is actually correct." ); } + private void testBlobOpen(){ + final sqlite3 db = createNewDb(); + + execSql(db, "CREATE TABLE T(a BLOB);" + +"INSERT INTO t(a) VALUES(cast('DEF' as text));"); + final OutputPointer.sqlite3_blob pOut = new OutputPointer.sqlite3_blob(); + int rc = sqlite3_blob_open(db, "main", "t", "a", + sqlite3_last_insert_rowid(db), 1, pOut); + affirm( 0==rc ); + final sqlite3_blob b = pOut.take(); + affirm( null!=b ); + affirm( 0!=b.getNativePointer() ); + affirm( 3==sqlite3_blob_bytes(b) ); + rc = sqlite3_blob_write( b, new byte[] {100, 101, 102}, 0); + affirm( 0==rc ); + rc = sqlite3_blob_close(b); + affirm( 0==rc ); + affirm( 0==b.getNativePointer() ); + sqlite3_stmt stmt = prepare(db,"SELECT length(a), a FROM t"); + affirm( SQLITE_ROW == sqlite3_step(stmt) ); + affirm( 3 == sqlite3_column_int(stmt,0) ); + affirm( "def".equals(sqlite3_column_text16(stmt,1)) ); + + sqlite3_finalize(stmt); + sqlite3_close_v2(db); + } + /* Copy/paste/rename this to add new tests. */ private void _testTemplate(){ final sqlite3 db = createNewDb(); diff --git a/ext/jni/src/org/sqlite/jni/sqlite3_blob.java b/ext/jni/src/org/sqlite/jni/sqlite3_blob.java new file mode 100644 index 0000000000..e512130256 --- /dev/null +++ b/ext/jni/src/org/sqlite/jni/sqlite3_blob.java @@ -0,0 +1,25 @@ +/* +** 2023-09-03 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file is part of the JNI bindings for the sqlite3 C API. +*/ +package org.sqlite.jni; + +/** + A wrapper for passing C-level (sqlite3_blob*) instances around in + Java. These wrappers do not own their associated pointer, they + simply provide a type-safe way to communicate it between Java and C + via JNI. +*/ +public final class sqlite3_blob extends NativePointerHolder { + // Only invoked from JNI. + private sqlite3_blob(){} +} diff --git a/manifest b/manifest index 294ff683d3..daa9e58d18 100644 --- a/manifest +++ b/manifest @@ -1,5 +1,5 @@ -C Expose\ssqlite3_system_errno()\sto\sJNI. -D 2023-09-03T12:46:09.429 +C Expose\sthe\ssqlite3_blob_...()\sAPIs\sto\sJNI. +D 2023-09-03T14:13:29.255 F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1 F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea F LICENSE.md df5091916dbb40e6e9686186587125e1b2ff51f022cc334e886c19a0e9982724 @@ -237,8 +237,8 @@ F ext/icu/sqliteicu.h fa373836ed5a1ee7478bdf8a1650689294e41d0c89c1daab26e9ae78a3 F ext/jni/GNUmakefile 7bd7f0c28d664b71b08f9d8ff507eb8329f1f3e7b5d88f774f90a1a5259a3fe8 F ext/jni/README.md 1332b1fa27918bd5d9ca2d0d4f3ac3a6ab86b9e3699dc5bfe32904a027f3d2a9 F ext/jni/jar-dist.make 030aaa4ae71dd86e4ec5e7c1e6cd86f9dfa47c4592c070d2e35157e42498e1fa -F ext/jni/src/c/sqlite3-jni.c 0ae08bc58a1304eaceb3d16bf3c799b717662ab59e66b8ca218a2041f4fc42f4 -F ext/jni/src/c/sqlite3-jni.h 2db486abbdd424a0197797908ea46e455b37876c41266a9630885e1469a897e8 +F ext/jni/src/c/sqlite3-jni.c 2a5a3f6637d34c3d8e8d60eac00b8ca231b0e97ce170d44c60a3afd040301104 +F ext/jni/src/c/sqlite3-jni.h 273e2ab8652d438e98bc891c8a80dcb4f9de82675124f0b090927532d8c5d212 F ext/jni/src/org/sqlite/jni/AbstractCollationCallback.java 95e88ba04f4aac51ffec65693e878e234088b2f21b387f4e4285c8b72b33e436 F ext/jni/src/org/sqlite/jni/AggregateFunction.java 7312486bc65fecdb91753c0a4515799194e031f45edbe16a6373cea18f404dc4 F ext/jni/src/org/sqlite/jni/AuthorizerCallback.java e6135be32f12bf140bffa39be7fd1a45ad83b2661ed49c08dbde04c8485feb38 @@ -256,16 +256,16 @@ F ext/jni/src/org/sqlite/jni/Fts5ExtensionApi.java 6ac342951c5805b48ba1e46dd41df F ext/jni/src/org/sqlite/jni/Fts5PhraseIter.java 6642beda341c0b1b46af4e2d7f6f9ab03a7aede43277b2c92859176d6bce3be9 F ext/jni/src/org/sqlite/jni/Fts5Tokenizer.java 91489893596b6528c0df5cd7180bd5b55809c26e2b797fb321dfcdbc1298c060 F ext/jni/src/org/sqlite/jni/NativePointerHolder.java 564087036449a16df148dcf0a067408bd251170bf23286c655f46b5f973e8b2d -F ext/jni/src/org/sqlite/jni/OutputPointer.java 1f2319976fff206f5056eafc8a4f48d43abe09d5d1b5287ba9145a95d847cbb7 +F ext/jni/src/org/sqlite/jni/OutputPointer.java 2f57c05672ddc9b38e3f8eed11759896cf0bf01107ffd24d5182b99f6e7254b6 F ext/jni/src/org/sqlite/jni/PreupdateHookCallback.java eccaed8dc9c6289f07ef3fc109891c6be1e7cc6c88723d90174b68706fc21cda F ext/jni/src/org/sqlite/jni/ProgressHandlerCallback.java 7b9ff2218129ece98ba60c57eeedcd8447e9e3b6e5d0f5e5d3eb0f0c5037d48d F ext/jni/src/org/sqlite/jni/ResultCode.java ba701f20213a5f259e94cfbfdd36eb7ac7ce7797f2c6c7fca2004ff12ce20f86 F ext/jni/src/org/sqlite/jni/RollbackHookCallback.java d12352c0e22840de484ffa9b11ed5058bb0daca2e9f218055d3c54c947a273c4 F ext/jni/src/org/sqlite/jni/SQLFunction.java 544a875d33fd160467d82e2397ac33157b29971d715a821a4fad3c899113ee8c -F ext/jni/src/org/sqlite/jni/SQLite3Jni.java bc5f5c2affa2126379696fc5e367b0fa02436166c8bd9f966a99559733acf1a9 +F ext/jni/src/org/sqlite/jni/SQLite3Jni.java 5b8890dcee68dda59c737a2e5acf34ae251b088daa1159f0a5cd78a087439239 F ext/jni/src/org/sqlite/jni/ScalarFunction.java 6d387bb499fbe3bc13c53315335233dbf6a0c711e8fa7c521683219b041c614c F ext/jni/src/org/sqlite/jni/TableColumnMetadata.java 54511b4297fa28dcb3f49b24035e34ced10e3fd44fd0e458e784f4d6b0096dab -F ext/jni/src/org/sqlite/jni/Tester1.java 14b3a129755a1a19271bdab9de6f4c58898aa28dfe3c03e7f0d23728254dc0d3 +F ext/jni/src/org/sqlite/jni/Tester1.java 1f38d134b732f0122ff7eace6945fa7093afe264fc158eebf66d193cba6ed294 F ext/jni/src/org/sqlite/jni/TesterFts5.java 1d127690daac4751300b277a14c09faa0cefd1efa365580cd8d95ea658e1ee59 F ext/jni/src/org/sqlite/jni/TraceV2Callback.java beb0b064c1a5f8bfe585a324ed39a4e33edbe379a3fc60f1401661620d3ca7c0 F ext/jni/src/org/sqlite/jni/UpdateHookCallback.java 8376f4a931f2d5612b295c003c9515ba933ee76d8f95610e89c339727376e36c @@ -282,6 +282,7 @@ F ext/jni/src/org/sqlite/jni/fts5_tokenizer.java a92c2e55bda492e4c76d48ddc73369b F ext/jni/src/org/sqlite/jni/package-info.java a3946db2504de747a1993c4f6e8ce604bec5a8e5a134b292c3b07527bc321a99 F ext/jni/src/org/sqlite/jni/sqlite3.java 62b1b81935ccf3393472d17cb883dc5ff39c388ec3bc1de547f098a0217158fc F ext/jni/src/org/sqlite/jni/sqlite3_backup.java d0bb06dd6225e76999ff6b7ab20f2643b1c4d4167431b3a93ea41943e41f094b +F ext/jni/src/org/sqlite/jni/sqlite3_blob.java f28a30134f2e524eb7d5ab87f57f86c90140341a6e8369ee54509ac8bb96fa82 F ext/jni/src/org/sqlite/jni/sqlite3_context.java 66ca95ce904044263a4aff684abe262d56f73e6b06bca6cf650761d79d7779ad F ext/jni/src/org/sqlite/jni/sqlite3_stmt.java 78e6d1b95ac600a9475e9db4623f69449322b0c93d1bd4e1616e76ed547ed9fc F ext/jni/src/org/sqlite/jni/sqlite3_value.java 3d1d4903e267bc0bc81d57d21f5e85978eff389a1a6ed46726dbe75f85e6914a @@ -2117,8 +2118,8 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93 F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0 -P d266acc23ecb7e76c8c68c6e89a76e6f3054f33f0262e60e06b258db5a5e2ccd -R 0f337c85b77ffdd11d583dfb2c7a7040 +P bac54da29c19ef5e0a76599b5d10b377ecd7b391a651af99526529df16a83c7d +R 282c1de5bd907fe2a4768bc91d128cea U stephan -Z 2f1ca87d5a540c0a7a17c3d282e87afc +Z eef925f2110921290c9a3b0a29c51189 # Remove this line to create a well-formed Fossil manifest. diff --git a/manifest.uuid b/manifest.uuid index d19f34cf7c..f88732c20e 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -bac54da29c19ef5e0a76599b5d10b377ecd7b391a651af99526529df16a83c7d \ No newline at end of file +9a9945c405cfe9b6bf399655f498457da66b06c8b92014510ab9fb83fbb1c7d4 \ No newline at end of file