diff options
28 files changed, 341 insertions, 114 deletions
diff --git a/ext/jni/GNUmakefile b/ext/jni/GNUmakefile index cd5150eb1..351851852 100644 --- a/ext/jni/GNUmakefile +++ b/ext/jni/GNUmakefile @@ -62,6 +62,8 @@ JAVA_FILES.main := $(patsubst %,$(dir.src.jni)/%,\ annotation/Canonical.java \ annotation/NotNull.java \ annotation/Nullable.java \ + annotation/package-info.java \ + AbstractCollationCallback.java \ AggregateFunction.java \ AuthorizerCallback.java \ AutoExtensionCallback.java \ @@ -327,7 +329,7 @@ dir.doc := $(dir.jni)/javadoc doc.index := $(dir.doc)/index.html $(doc.index): $(JAVA_FILES.main) $(MAKEFILE) @if [ -d $(dir.doc) ]; then rm -fr $(dir.doc)/*; fi - $(bin.javadoc) -cp $(classpath) -d $(dir.doc) -quiet org.sqlite.jni + $(bin.javadoc) -cp $(classpath) -d $(dir.doc) -quiet -subpackages org.sqlite.jni @echo "javadoc output is in $@" .PHONY: doc javadoc docserve diff --git a/ext/jni/src/c/sqlite3-jni.c b/ext/jni/src/c/sqlite3-jni.c index 0f18fa5a0..471cc1503 100644 --- a/ext/jni/src/c/sqlite3-jni.c +++ b/ext/jni/src/c/sqlite3-jni.c @@ -2517,6 +2517,15 @@ S3JniApi(sqlite3_column_text(),jbyteArray,1column_1text_1utf8)( return p ? s3jni_new_jbyteArray(p, n) : NULL; } +S3JniApi(sqlite3_column_text(),jstring,1column_1text)( + JniArgsEnvClass, jobject jpStmt, jint ndx +){ + sqlite3_stmt * const stmt = PtrGet_sqlite3_stmt(jpStmt); + const int n = sqlite3_column_bytes(stmt, (int)ndx); + const unsigned char * const p = sqlite3_column_text(stmt, (int)ndx); + return p ? s3jni_utf8_to_jstring( (const char *)p, n) : 0; +} + S3JniApi(sqlite3_column_text16(),jstring,1column_1text16)( JniArgsEnvClass, jobject jpStmt, jint ndx ){ diff --git a/ext/jni/src/c/sqlite3-jni.h b/ext/jni/src/c/sqlite3-jni.h index 7c44dfd75..40dd44990 100644 --- a/ext/jni/src/c/sqlite3-jni.h +++ b/ext/jni/src/c/sqlite3-jni.h @@ -1045,6 +1045,14 @@ JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1tex /* * Class: org_sqlite_jni_SQLite3Jni + * Method: sqlite3_column_text + * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1text + (JNIEnv *, jclass, jobject, jint); + +/* + * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_column_text16 * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)Ljava/lang/String; */ diff --git a/ext/jni/src/org/sqlite/jni/AbstractCollationCallback.java b/ext/jni/src/org/sqlite/jni/AbstractCollationCallback.java new file mode 100644 index 000000000..63cac66a5 --- /dev/null +++ b/ext/jni/src/org/sqlite/jni/AbstractCollationCallback.java @@ -0,0 +1,34 @@ +/* +** 2023-08-25 +** +** 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; +import org.sqlite.jni.annotation.NotNull; + +/** + An implementation of {@link CollationCallback} which provides a + no-op xDestroy() method. +*/ +public abstract class AbstractCollationCallback + implements CollationCallback, XDestroyCallback { + /** + Must compare the given byte arrays and return the result using + {@code memcmp()} semantics. + */ + public abstract int call(@NotNull byte[] lhs, @NotNull byte[] rhs); + + /** + Optionally override to be notified when the UDF is finalized by + SQLite. This implementation does nothing. + */ + public void xDestroy(){} +} diff --git a/ext/jni/src/org/sqlite/jni/AggregateFunction.java b/ext/jni/src/org/sqlite/jni/AggregateFunction.java index 033e4dbca..502cde12f 100644 --- a/ext/jni/src/org/sqlite/jni/AggregateFunction.java +++ b/ext/jni/src/org/sqlite/jni/AggregateFunction.java @@ -15,12 +15,12 @@ package org.sqlite.jni; /** - SQLFunction subclass for creating aggregate functions. Its T is - the data type of its "accumulator" state, an instance of which is + A SQLFunction implementation for aggregate functions. Its T is the + data type of its "accumulator" state, an instance of which is intended to be be managed using the getAggregateState() and takeAggregateState() methods. */ -public abstract class AggregateFunction<T> extends SQLFunction { +public abstract class AggregateFunction<T> implements SQLFunction { /** As for the xStep() argument of the C API's @@ -48,7 +48,7 @@ public abstract class AggregateFunction<T> extends SQLFunction { /** To be called from the implementation's xStep() method, as well - as the xValue() and xInverse() methods of the Window<T> + as the xValue() and xInverse() methods of the {@link WindowFunction} subclass, to fetch the current per-call UDF state. On the first call to this method for any given sqlite3_context argument, the context is set to the given initial value. On all other diff --git a/ext/jni/src/org/sqlite/jni/AuthorizerCallback.java b/ext/jni/src/org/sqlite/jni/AuthorizerCallback.java index eef7e5020..a9f15fc6c 100644 --- a/ext/jni/src/org/sqlite/jni/AuthorizerCallback.java +++ b/ext/jni/src/org/sqlite/jni/AuthorizerCallback.java @@ -15,14 +15,12 @@ package org.sqlite.jni; import org.sqlite.jni.annotation.*; /** - Callback for use with sqlite3_set_authorizer(). + Callback for use with {@link SQLite3Jni#sqlite3_set_authorizer}. */ public interface AuthorizerCallback extends SQLite3CallbackProxy { /** Must function as described for the C-level sqlite3_set_authorizer() callback. - - Must not throw. */ int call(int opId, @Nullable String s1, @Nullable String s2, @Nullable String s3, @Nullable String s4); diff --git a/ext/jni/src/org/sqlite/jni/AutoExtensionCallback.java b/ext/jni/src/org/sqlite/jni/AutoExtensionCallback.java index 11786c95e..1f8ace2fb 100644 --- a/ext/jni/src/org/sqlite/jni/AutoExtensionCallback.java +++ b/ext/jni/src/org/sqlite/jni/AutoExtensionCallback.java @@ -14,28 +14,27 @@ package org.sqlite.jni; /** - A callback for use with the sqlite3_auto_extension() family of - APIs. + Callback for use with the {@link SQLite3Jni#sqlite3_auto_extension} + family of APIs. */ public interface AutoExtensionCallback extends SQLite3CallbackProxy { /** Must function as described for a C-level - sqlite3_auto_extension() callback, with the caveat that the - signature is shorter. + sqlite3_auto_extension() callback. - This callback may throw and the exception's error message will + <p>This callback may throw and the exception's error message will be set as the db's error string. - Tips for implementations: + <p>Tips for implementations: - - Opening a database from an auto-extension handler will lead to + <p>- Opening a database from an auto-extension handler will lead to an endless recursion of the auto-handler triggering itself indirectly for each newly-opened database. - - If this routine is stateful, it may be useful to make the + <p>- If this routine is stateful, it may be useful to make the overridden method synchronized. - - Results are undefined if db is closed by an auto-extension. + <p>- Results are undefined if the given db is closed by an auto-extension. */ int call(sqlite3 db); } diff --git a/ext/jni/src/org/sqlite/jni/BusyHandlerCallback.java b/ext/jni/src/org/sqlite/jni/BusyHandlerCallback.java index 77180e2c2..db9295bb6 100644 --- a/ext/jni/src/org/sqlite/jni/BusyHandlerCallback.java +++ b/ext/jni/src/org/sqlite/jni/BusyHandlerCallback.java @@ -13,18 +13,14 @@ */ package org.sqlite.jni; - /** - Callback for use with sqlite3_busy_handler() + Callback for use with {@link SQLite3Jni#sqlite3_busy_handler}. */ -public abstract class BusyHandlerCallback implements SQLite3CallbackProxy { +public interface BusyHandlerCallback extends SQLite3CallbackProxy { /** Must function as documented for the C-level sqlite3_busy_handler() callback argument, minus the (void*) argument the C-level function requires. - - Any exceptions thrown by this callback are suppressed in order to - retain the C-style API semantics of the JNI bindings. */ - public abstract int call(int n); + int call(int n); } diff --git a/ext/jni/src/org/sqlite/jni/CollationCallback.java b/ext/jni/src/org/sqlite/jni/CollationCallback.java index 1e4d0396d..481c6cd95 100644 --- a/ext/jni/src/org/sqlite/jni/CollationCallback.java +++ b/ext/jni/src/org/sqlite/jni/CollationCallback.java @@ -12,20 +12,24 @@ ** This file is part of the JNI bindings for the sqlite3 C API. */ package org.sqlite.jni; +import org.sqlite.jni.annotation.NotNull; /** - Callback for use with sqlite3_create_collation() + Callback for use with {@link SQLite3Jni#sqlite3_create_collation}. + + @see AbstractCollationCallback */ -public abstract class CollationCallback - implements SQLite3CallbackProxy, XDestroyCallback { +public interface CollationCallback + extends SQLite3CallbackProxy, XDestroyCallback { /** - Must compare the given byte arrays using memcmp() semantics. + Must compare the given byte arrays and return the result using + {@code memcmp()} semantics. */ - public abstract int call(byte[] lhs, byte[] rhs); + int call(@NotNull byte[] lhs, @NotNull byte[] rhs); /** Called by SQLite when the collation is destroyed. If a collation requires custom cleanup, override this method. */ - public void xDestroy(){} + void xDestroy(); } diff --git a/ext/jni/src/org/sqlite/jni/CollationNeededCallback.java b/ext/jni/src/org/sqlite/jni/CollationNeededCallback.java index a8b17fe48..e6c917a2c 100644 --- a/ext/jni/src/org/sqlite/jni/CollationNeededCallback.java +++ b/ext/jni/src/org/sqlite/jni/CollationNeededCallback.java @@ -14,7 +14,7 @@ package org.sqlite.jni; /** - Callback for use with sqlite3_collation_needed(). + Callback for use with {@link SQLite3Jni#sqlite3_collation_needed}. */ public interface CollationNeededCallback extends SQLite3CallbackProxy { /** diff --git a/ext/jni/src/org/sqlite/jni/CommitHookCallback.java b/ext/jni/src/org/sqlite/jni/CommitHookCallback.java index 7757a6ac0..253d0b8cf 100644 --- a/ext/jni/src/org/sqlite/jni/CommitHookCallback.java +++ b/ext/jni/src/org/sqlite/jni/CommitHookCallback.java @@ -14,7 +14,7 @@ package org.sqlite.jni; /** - Callback for use with sqlite3_commit_hook() + Callback for use with {@link SQLite3Jni#sqlite3_commit_hook}. */ public interface CommitHookCallback extends SQLite3CallbackProxy { /** diff --git a/ext/jni/src/org/sqlite/jni/PreupdateHookCallback.java b/ext/jni/src/org/sqlite/jni/PreupdateHookCallback.java index f0b16ae92..b68dd4b6d 100644 --- a/ext/jni/src/org/sqlite/jni/PreupdateHookCallback.java +++ b/ext/jni/src/org/sqlite/jni/PreupdateHookCallback.java @@ -14,12 +14,12 @@ package org.sqlite.jni; /** - Callback for use with sqlite3_preupdate_hook(). + Callback for use with {@link SQLite3Jni#sqlite3_preupdate_hook}. */ public interface PreupdateHookCallback extends SQLite3CallbackProxy { /** Must function as described for the C-level sqlite3_preupdate_hook() - callback. Must not throw. + callback. */ void call(sqlite3 db, int op, String dbName, String dbTable, long iKey1, long iKey2 ); diff --git a/ext/jni/src/org/sqlite/jni/ProgressHandlerCallback.java b/ext/jni/src/org/sqlite/jni/ProgressHandlerCallback.java index 447bba6f3..d15bf31a1 100644 --- a/ext/jni/src/org/sqlite/jni/ProgressHandlerCallback.java +++ b/ext/jni/src/org/sqlite/jni/ProgressHandlerCallback.java @@ -14,13 +14,13 @@ package org.sqlite.jni; /** - Callback for use with sqlite3_progress_handler() + Callback for use with {@link SQLite3Jni#sqlite3_progress_handler}. */ public interface ProgressHandlerCallback extends SQLite3CallbackProxy { /** Works as documented for the C-level sqlite3_progress_handler() callback. - If it throws, the exception message is passed on to the db and + <p>If it throws, the exception message is passed on to the db and the exception is suppressed. */ int call(); diff --git a/ext/jni/src/org/sqlite/jni/RollbackHookCallback.java b/ext/jni/src/org/sqlite/jni/RollbackHookCallback.java index 7bf387941..3bf9f79a1 100644 --- a/ext/jni/src/org/sqlite/jni/RollbackHookCallback.java +++ b/ext/jni/src/org/sqlite/jni/RollbackHookCallback.java @@ -14,12 +14,12 @@ package org.sqlite.jni; /** - Callback for use with sqlite3_rollback_hook() + Callback for use with {@link SQLite3Jni#sqlite3_rollback_hook}. */ public interface RollbackHookCallback extends SQLite3CallbackProxy { /** Works as documented for the C-level sqlite3_rollback_hook() - callback. Must not throw. + callback. */ void call(); } diff --git a/ext/jni/src/org/sqlite/jni/SQLFunction.java b/ext/jni/src/org/sqlite/jni/SQLFunction.java index badbc3dc7..66119ebe5 100644 --- a/ext/jni/src/org/sqlite/jni/SQLFunction.java +++ b/ext/jni/src/org/sqlite/jni/SQLFunction.java @@ -31,7 +31,7 @@ package org.sqlite.jni; SQLFunction base class and the method names and signatures used by the UDF callback interfaces. */ -public abstract class SQLFunction { +public interface SQLFunction { /** PerContextState assists aggregate and window functions in @@ -53,11 +53,11 @@ public abstract class SQLFunction { state, of a client-defined type (the T part of this class), which persists across a "matching set" of the UDF's callbacks. - <p>This class is a helper providing commonly-needed functionality - - it is not required for use with aggregate or window functions. + <p>This class is a helper providing commonly-needed functionality + - it is not required for use with aggregate or window functions. Client UDFs are free to perform such mappings using custom - approaches. The provided Aggregate<T> and Window<T> classes - use this. + approaches. The provided {@link AggregateFunction} and {@link + WindowFunction} classes use this. */ public static final class PerContextState<T> { private final java.util.Map<Long,ValueHolder<T>> map diff --git a/ext/jni/src/org/sqlite/jni/SQLite3CallbackProxy.java b/ext/jni/src/org/sqlite/jni/SQLite3CallbackProxy.java index 137cddcc5..505266493 100644 --- a/ext/jni/src/org/sqlite/jni/SQLite3CallbackProxy.java +++ b/ext/jni/src/org/sqlite/jni/SQLite3CallbackProxy.java @@ -18,17 +18,27 @@ package org.sqlite.jni; classes which have a call() method implementing some specific callback interface on behalf of the C library. + <p>Unless very explicitely documented otherwise, callbacks must + never throw. Any which do throw but should not might trigger debug + output regarding the error, but the exception will not be + propagated. For callback interfaces which support returning error + info to the core, the JNI binding will convert any exceptions to + C-level error information. For callback interfaces which do not + support, all exceptions will necessarily be suppressed in order to + retain the C-style no-throw semantics. + <p>Callbacks of this style follow a common naming convention: <p>1) They use the UpperCamelCase form of the C function they're - proxying for, minus the sqlite3_ prefix, plus a Callback - suffix. e.g. sqlite3_busy_handler()'s callback is named - BusyHandlerCallback. Exceptions are made where that would - potentially be ambiguous, e.g. ConfigSqllogCallback instead of - config_callback because the sqlite3_config() interface may need to - support more callback types in the future. + proxying for, minus the {@code sqlite3_} prefix, plus a {@code + Callback} suffix. e.g. {@code sqlite3_busy_handler()}'s callback is + named {@code BusyHandlerCallback}. Exceptions are made where that + would potentially be ambiguous, e.g. {@link ConfigSqllogCallback} + instead of {@code ConfigCallback} because the {@code + sqlite3_config()} interface may need to support more callback types + in the future. - <p>2) They all have a call() method but its signature is + <p>2) They all have a {@code call()} method but its signature is callback-specific. */ public interface SQLite3CallbackProxy {} diff --git a/ext/jni/src/org/sqlite/jni/SQLite3Jni.java b/ext/jni/src/org/sqlite/jni/SQLite3Jni.java index 1e02b41be..6cad93d74 100644 --- a/ext/jni/src/org/sqlite/jni/SQLite3Jni.java +++ b/ext/jni/src/org/sqlite/jni/SQLite3Jni.java @@ -324,70 +324,87 @@ public final class SQLite3Jni { @NotNull sqlite3 db, int ms ); + @Canonical public static native boolean sqlite3_cancel_auto_extension( @NotNull AutoExtensionCallback ax ); + @Canonical public static native int sqlite3_changes( @NotNull sqlite3 db ); + @Canonical public static native long sqlite3_changes64( @NotNull sqlite3 db ); + @Canonical public static native int sqlite3_clear_bindings( @NotNull sqlite3_stmt stmt ); + @Canonical public static native int sqlite3_close( @Nullable sqlite3 db ); + @Canonical public static native int sqlite3_close_v2( @Nullable sqlite3 db ); + @Canonical public static native byte[] sqlite3_column_blob( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native int sqlite3_column_bytes( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native int sqlite3_column_bytes16( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native int sqlite3_column_count( @NotNull sqlite3_stmt stmt ); + @Canonical public static native double sqlite3_column_double( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native int sqlite3_column_int( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native long sqlite3_column_int64( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native String sqlite3_column_name( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native String sqlite3_column_database_name( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native String sqlite3_column_origin_name( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native String sqlite3_column_table_name( @NotNull sqlite3_stmt stmt, int ndx ); @@ -396,18 +413,25 @@ public final class SQLite3Jni { Returns the given column's contents as UTF-8-encoded (not MUTF-8) text. Returns null if the C-level sqlite3_column_text() returns NULL. + + @see #sqlite3_column_text */ + @Canonical(cname="sqlite3_column_text") public static native byte[] sqlite3_column_text_utf8( @NotNull sqlite3_stmt stmt, int ndx ); - public static String sqlite3_column_text( + /** + Provides the same feature as the same-named C API but returns the + text in Java-native encoding rather than the C API's UTF-8. + + @see #sqlite3_column_text16 + */ + public static native String sqlite3_column_text( @NotNull sqlite3_stmt stmt, int ndx - ){ - final byte[] ba = sqlite3_column_text_utf8(stmt, ndx); - return ba==null ? null : new String(ba, StandardCharsets.UTF_8); - } + ); + @Canonical public static native String sqlite3_column_text16( @NotNull sqlite3_stmt stmt, int ndx ); @@ -449,10 +473,12 @@ public final class SQLite3Jni { // return rv; // } + @Canonical public static native int sqlite3_column_type( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical public static native sqlite3_value sqlite3_column_value( @NotNull sqlite3_stmt stmt, int ndx ); @@ -461,22 +487,27 @@ public final class SQLite3Jni { This functions like C's sqlite3_collation_needed16() because Java's string type is compatible with that interface. */ + @Canonical public static native int sqlite3_collation_needed( @NotNull sqlite3 db, @Nullable CollationNeededCallback callback ); + @Canonical public static native sqlite3 sqlite3_context_db_handle( @NotNull sqlite3_context cx ); + @Canonical public static native CommitHookCallback sqlite3_commit_hook( @NotNull sqlite3 db, @Nullable CommitHookCallback hook ); + @Canonical public static native String sqlite3_compileoption_get( int n ); + @Canonical public static native boolean sqlite3_compileoption_used( @NotNull String optName ); @@ -497,6 +528,9 @@ public final class SQLite3Jni { library APIs are being called. */ + @Canonical(comment="Option subset: "+ + "SQLITE_CONFIG_SINGLETHREAD, SQLITE_CONFIG_MULTITHREAD, "+ + "SQLITE_CONFIG_SERIALIZED") public static native int sqlite3_config(int op); /** @@ -514,8 +548,10 @@ public final class SQLite3Jni { library APIs are being called. */ + @Canonical(comment="Option subset: SQLITE_CONFIG_SQLLOG") public static native int sqlite3_config( @Nullable ConfigSqllogCallback logger ); + @Canonical public static native int sqlite3_create_collation( @NotNull sqlite3 db, @NotNull String name, int eTextRep, @NotNull CollationCallback col @@ -529,11 +565,13 @@ public final class SQLite3Jni { SQLFunction's subclasses (ScalarFunction, AggregateFunction<T>, and WindowFunction<T>) for details. */ + @Canonical public static native int sqlite3_create_function( @NotNull sqlite3 db, @NotNull String functionName, int nArg, int eTextRep, @NotNull SQLFunction func ); + @Canonical public static native int sqlite3_data_count( @NotNull sqlite3_stmt stmt ); @@ -543,6 +581,7 @@ public final class SQLite3Jni { variadic arguments. Returns SQLITE_MISUSE if op is not one of the SQLITE_DBCONFIG_... options which uses this call form. */ + @Canonical public static native int sqlite3_db_config( @NotNull sqlite3 db, int op, int onOff, @Nullable OutputPointer.Int32 out ); @@ -554,53 +593,71 @@ public final class SQLite3Jni { SQLITE_DBCONFIG_MAINDBNAME, but that set of options may be extended in future versions. */ + @Canonical(comment="Supports only a subset of options.") public static native int sqlite3_db_config( @NotNull sqlite3 db, int op, @NotNull String val ); + @Canonical public static native String sqlite3_db_filename( @NotNull sqlite3 db, @NotNull String dbName ); + @Canonical public static native sqlite3 sqlite3_db_handle( @NotNull sqlite3_stmt stmt ); + @Canonical public static native int sqlite3_db_status( @NotNull sqlite3 db, int op, @NotNull OutputPointer.Int32 pCurrent, @NotNull OutputPointer.Int32 pHighwater, boolean reset ); + @Canonical public static native int sqlite3_errcode(@NotNull sqlite3 db); + @Canonical public static native String sqlite3_expanded_sql(@NotNull sqlite3_stmt stmt); + @Canonical public static native int sqlite3_extended_errcode(@NotNull sqlite3 db); + @Canonical public static native boolean sqlite3_extended_result_codes( @NotNull sqlite3 db, boolean onoff ); + @Canonical public static native String sqlite3_errmsg(@NotNull sqlite3 db); + @Canonical public static native String sqlite3_errstr(int resultCode); /** Note that the returned byte offset values assume UTF-8-encoded inputs, so won't always match character offsets in Java Strings. */ + @Canonical public static native int sqlite3_error_offset(@NotNull sqlite3 db); + @Canonical public static native int sqlite3_finalize(@NotNull sqlite3_stmt stmt); + @Canonical public static native int sqlite3_initialize(); + @Canonical public static native void sqlite3_interrupt(@NotNull sqlite3 db); + @Canonical public static native boolean sqlite3_is_interrupted(@NotNull sqlite3 db); + @Canonical public static native long sqlite3_last_insert_rowid(@NotNull sqlite3 db); + @Canonical public static native String sqlite3_libversion(); + @Canonical public static native int sqlite3_libversion_number(); /** @@ -616,6 +673,7 @@ public final class SQLite3Jni { object and it is up to the caller to sqlite3_close() that db handle. */ + @Canonical public static native int sqlite3_open( @Nullable String filename, @NotNull OutputPointer.sqlite3 ppDb ); @@ -634,6 +692,7 @@ public final class SQLite3Jni { return out.take(); }; + @Canonical public static native int sqlite3_open_v2( @Nullable String filename, @NotNull OutputPointer.sqlite3 ppDb, int flags, @Nullable String zVfs @@ -670,6 +729,7 @@ public final class SQLite3Jni { necessary, however, and overloads are provided which gloss over that. */ + @Canonical private static native int sqlite3_prepare( @NotNull sqlite3 db, @NotNull byte[] sqlUtf8, int maxBytes, @NotNull OutputPointer.sqlite3_stmt outStmt, @@ -719,6 +779,7 @@ public final class SQLite3Jni { See sqlite3_prepare() for details about the slight API differences from the C API. */ + @Canonical private static native int sqlite3_prepare_v2( @NotNull sqlite3 db, @NotNull byte[] sqlUtf8, int maxBytes, @NotNull OutputPointer.sqlite3_stmt outStmt, @@ -760,6 +821,7 @@ public final class SQLite3Jni { return out.take(); } + @Canonical private static native int sqlite3_prepare_v3( @NotNull sqlite3 db, @NotNull byte[] sqlUtf8, int maxBytes, int prepFlags, @NotNull OutputPointer.sqlite3_stmt outStmt, @@ -806,18 +868,21 @@ public final class SQLite3Jni { acts as a proxy for C's sqlite3_preupdate_blobwrite(), else it returns SQLITE_MISUSE with no side effects. */ + @Canonical public static native int sqlite3_preupdate_blobwrite(@NotNull sqlite3 db); /** If the C API was built with SQLITE_ENABLE_PREUPDATE_HOOK defined, this acts as a proxy for C's sqlite3_preupdate_count(), else it returns SQLITE_MISUSE with no side effects. */ + @Canonical public static native int sqlite3_preupdate_count(@NotNull sqlite3 db); /** If the C API was built with SQLITE_ENABLE_PREUPDATE_HOOK defined, this acts as a proxy for C's sqlite3_preupdate_depth(), else it returns SQLITE_MISUSE with no side effects. */ + @Canonical public static native int sqlite3_preupdate_depth(@NotNull sqlite3 db); /** @@ -825,6 +890,7 @@ public final class SQLite3Jni { acts as a proxy for C's sqlite3_preupdate_hook(), else it returns null with no side effects. */ + @Canonical public static native PreupdateHookCallback sqlite3_preupdate_hook( @NotNull sqlite3 db, @Nullable PreupdateHookCallback hook ); @@ -834,6 +900,7 @@ public final class SQLite3Jni { this acts as a proxy for C's sqlite3_preupdate_new(), else it returns SQLITE_MISUSE with no side effects. */ + @Canonical public static native int sqlite3_preupdate_new(@NotNull sqlite3 db, int col, @NotNull OutputPointer.sqlite3_value out); @@ -852,6 +919,7 @@ public final class SQLite3Jni { this acts as a proxy for C's sqlite3_preupdate_old(), else it returns SQLITE_MISUSE with no side effects. */ + @Canonical public static native int sqlite3_preupdate_old(@NotNull sqlite3 db, int col, @NotNull OutputPointer.sqlite3_value out); @@ -865,10 +933,12 @@ public final class SQLite3Jni { return out.take(); } + @Canonical public static native void sqlite3_progress_handler( @NotNull sqlite3 db, int n, @Nullable ProgressHandlerCallback h ); + @Canonical public static native int sqlite3_reset(@NotNull sqlite3_stmt stmt); /** @@ -876,8 +946,10 @@ public final class SQLite3Jni { extensions are currently running. (The JNI-level list of extensions cannot be manipulated while it is being traversed.) */ + @Canonical public static native void sqlite3_reset_auto_extension(); + @Canonical public static native void sqlite3_result_double( @NotNull sqlite3_context cx, double v ); @@ -889,6 +961,7 @@ public final class SQLite3Jni { results in the C-level sqlite3_result_error() being called with a complaint about the invalid argument. */ + @Canonical private static native void sqlite3_result_error( @NotNull sqlite3_context cx, @NotNull byte[] msg, int eTextRep ); @@ -929,26 +1002,32 @@ public final class SQLite3Jni { sqlite3_result_error(cx, e.getMessage()); } + @Canonical public static native void sqlite3_result_error_toobig( @NotNull sqlite3_context cx ); + @Canonical public static native void sqlite3_result_error_nomem( @NotNull sqlite3_context cx ); + @Canonical public static native void sqlite3_result_error_code( @NotNull sqlite3_context cx, int c ); + @Canonical public static native void sqlite3_result_null( @NotNull sqlite3_context cx ); + @Canonical public static native void sqlite3_result_int( @NotNull sqlite3_context cx, int v ); + @Canonical public static native void sqlite3_result_int64( @NotNull sqlite3_context cx, long v ); @@ -1031,18 +1110,22 @@ public final class SQLite3Jni { sqlite3_result_text(cx, v); } + @Canonical public static native void sqlite3_result_value( @NotNull sqlite3_context cx, @NotNull sqlite3_value v ); + @Canonical public static native void sqlite3_result_zeroblob( @NotNull sqlite3_context cx, int n ); + @Canonical public static native int sqlite3_result_zeroblob64( @NotNull sqlite3_context cx, long n ); + @Canonical private static native void sqlite3_result_blob( @NotNull sqlite3_context cx, @Nullable byte[] blob, int maxLen ); @@ -1068,6 +1151,7 @@ public final class SQLite3Jni { If @param maxLen is larger than blob.length, it is truncated to that value. If it is negative, results are undefined. */ + @Canonical private static native void sqlite3_result_blob64( @NotNull sqlite3_context cx, @Nullable byte[] blob, long maxLen ); @@ -1078,6 +1162,7 @@ public final class SQLite3Jni { sqlite3_result_blob64(cx, blob, (long)(null==blob ? 0 : blob.length)); } + @Canonical private static native void sqlite3_result_text( @NotNull sqlite3_context cx, @Nullable byte[] utf8, int maxLen ); @@ -1118,6 +1203,7 @@ public final class SQLite3Jni { negative, results are undefined. If text is null, the subsequent arguments are ignored. */ + @Canonical private static native void sqlite3_result_text64( @NotNull sqlite3_context cx, @Nullable byte[] text, long maxLength, int encoding @@ -1143,15 +1229,17 @@ public final class SQLite3Jni { } } + @Canonical public static native RollbackHookCallback sqlite3_rollback_hook( @NotNull sqlite3 db, @Nullable RollbackHookCallback hook ); - //! Sets or unsets (if auth is null) the current authorizer. + @Canonical public static native int sqlite3_set_authorizer( @NotNull sqlite3 db, @Nullable AuthorizerCallback auth ); + @Canonical public static native void sqlite3_set_last_insert_rowid( @NotNull sqlite3 db, long rowid ); @@ -1166,31 +1254,39 @@ public final class SQLite3Jni { to use those objects after this routine is called invoked undefined behavior. */ + @Canonical public static synchronized native int sqlite3_shutdown(); + @Canonical public static native int sqlite3_sleep(int ms); + @Canonical public static native String sqlite3_sourceid(); + @Canonical public static native String sqlite3_sql(@NotNull sqlite3_stmt stmt); + @Canonical public static native int sqlite3_status( int op, @NotNull OutputPointer.Int32 pCurrent, @NotNull OutputPointer.Int32 pHighwater, boolean reset ); + @Canonical public static native int sqlite3_status64( int op, @NotNull OutputPointer.Int64 pCurrent, @NotNull OutputPointer.Int64 pHighwater, boolean reset ); + @Canonical public static native int sqlite3_step(@NotNull sqlite3_stmt stmt); /** Internal impl of the public sqlite3_strglob() method. Neither argument may be NULL and both MUST be NUL-terminated UTF-8. */ + @Canonical private static native int sqlite3_strglob( @NotNull byte[] glob, @NotNull byte[] txt ); @@ -1208,6 +1304,7 @@ public final class SQLite3Jni { Internal impl of the public sqlite3_strlike() method. Neither argument may be NULL and both MUST be NUL-terminated UTF-8. */ + @Canonical private static native int sqlite3_strlike( @NotNull byte[] glob, @NotNull byte[] txt, int escChar ); @@ -1222,10 +1319,13 @@ public final class SQLite3Jni { ); } + @Canonical public static native int sqlite3_threadsafe(); + @Canonical public static native int sqlite3_total_changes(@NotNull sqlite3 db); + @Canonical public static native long sqlite3_total_changes64(@NotNull sqlite3 db); /** @@ -1237,32 +1337,43 @@ public final class SQLite3Jni { implementation returns non-0 if initialization of the tracer mapping state fails. */ + @Canonical public static native int sqlite3_trace_v2( @NotNull sqlite3 db, int traceMask, @Nullable TraceV2Callback tracer ); + @Canonical public static native UpdateHookCallback sqlite3_update_hook( sqlite3 db, UpdateHookCallback hook ); + @Canonical public static native byte[] sqlite3_value_blob(@NotNull sqlite3_value v); + @Canonical public static native int sqlite3_value_bytes(@NotNull sqlite3_value v); + @Canonical public static native int sqlite3_value_bytes16(@NotNull sqlite3_value v); + @Canonical public static native double sqlite3_value_double(@NotNull sqlite3_value v); + @Canonical public static native sqlite3_value sqlite3_value_dup( @NotNull sqlite3_value v ); + @Canonical public static native int sqlite3_value_encoding(@NotNull sqlite3_value v); + @Canonical public static native void sqlite3_value_free(@Nullable sqlite3_value v); + @Canonical public static native int sqlite3_value_int(@NotNull sqlite3_value v); + @Canonical public static native long sqlite3_value_int64(@NotNull sqlite3_value v); /** @@ -1293,8 +1404,17 @@ public final class SQLite3Jni { Returns the given value as UTF-8-encoded bytes, or null if the underlying C-level sqlite3_value_text() returns NULL. */ + @Canonical(cname="sqlite3_value_text", + comment="Renamed because its String-returning overload would "+ + "otherwise be ambiguous.") public static native byte[] sqlite3_value_text_utf8(@NotNull sqlite3_value v); + /** + Provides the same feature as the same-named C API but returns the + text in Java-native encoding rather than the C API's UTF-8. + + @see #sqlite3_value_text16 + */ public static native String sqlite3_value_text(@NotNull sqlite3_value v); /** @@ -1305,16 +1425,22 @@ public final class SQLite3Jni { sqlite3_value_text() fetches UTF-8 (SQLite's default encoding) and converts it to UTF-16 in Java. */ + @Canonical public static native String sqlite3_value_text16(@NotNull sqlite3_value v); + @Canonical public static native int sqlite3_value_type(@NotNull sqlite3_value v); + @Canonical public static native int sqlite3_value_numeric_type(@NotNull sqlite3_value v); + @Canonical public static native int sqlite3_value_nochange(@NotNull sqlite3_value v); + @Canonical public static native int sqlite3_value_frombind(@NotNull sqlite3_value v); + @Canonical public static native int sqlite3_value_subtype(@NotNull sqlite3_value v); /** diff --git a/ext/jni/src/org/sqlite/jni/ScalarFunction.java b/ext/jni/src/org/sqlite/jni/ScalarFunction.java index 9d75dbdb7..73fb58cda 100644 --- a/ext/jni/src/org/sqlite/jni/ScalarFunction.java +++ b/ext/jni/src/org/sqlite/jni/ScalarFunction.java @@ -15,9 +15,9 @@ package org.sqlite.jni; /** - SQLFunction subclass for creating scalar functions. + A SQLFunction implementation for scalar functions. */ -public abstract class ScalarFunction extends SQLFunction { +public abstract class ScalarFunction implements SQLFunction { /** As for the xFunc() argument of the C API's sqlite3_create_function(). If this function throws, it is @@ -27,7 +27,7 @@ public abstract class ScalarFunction extends SQLFunction { /** Optionally override to be notified when the UDF is finalized by - SQLite. + SQLite. This implementation does nothing. */ public void xDestroy() {} } diff --git a/ext/jni/src/org/sqlite/jni/TraceV2Callback.java b/ext/jni/src/org/sqlite/jni/TraceV2Callback.java index 453cf948d..897aeefa9 100644 --- a/ext/jni/src/org/sqlite/jni/TraceV2Callback.java +++ b/ext/jni/src/org/sqlite/jni/TraceV2Callback.java @@ -12,9 +12,10 @@ ** This file is part of the JNI bindings for the sqlite3 C API. */ package org.sqlite.jni; +import org.sqlite.jni.annotation.Nullable; /** - Callback proxy for use with sqlite3_trace_v2(). + Callback for use with {@link SQLite3Jni#sqlite3_trace_v2}. */ public interface TraceV2Callback extends SQLite3CallbackProxy { /** @@ -23,7 +24,7 @@ public interface TraceV2Callback extends SQLite3CallbackProxy { argument to the native trace callback, as that role is better filled by instance-local state. - These callbacks may throw, in which case their exceptions are + <p>These callbacks may throw, in which case their exceptions are converted to C-level error information. <p>The 2nd argument to this function, if non-null, will be a an @@ -45,5 +46,5 @@ public interface TraceV2Callback extends SQLite3CallbackProxy { <p>- SQLITE_TRACE_CLOSE: pNative is a sqlite3. pX is null. */ - int call(int traceFlag, Object pNative, Object pX); + int call(int traceFlag, Object pNative, @Nullable Object pX); } diff --git a/ext/jni/src/org/sqlite/jni/UpdateHookCallback.java b/ext/jni/src/org/sqlite/jni/UpdateHookCallback.java index 17c49ba27..4fd0a6324 100644 --- a/ext/jni/src/org/sqlite/jni/UpdateHookCallback.java +++ b/ext/jni/src/org/sqlite/jni/UpdateHookCallback.java @@ -14,12 +14,12 @@ package org.sqlite.jni; /** - Callback for use with sqlite3_update_hook(). + Callback for use with {@link SQLite3Jni#sqlite3_update_hook}. */ public interface UpdateHookCallback extends SQLite3CallbackProxy { /** Must function as described for the C-level sqlite3_update_hook() - callback. Must not throw. + callback. */ void call(int opId, String dbName, String tableName, long rowId); } diff --git a/ext/jni/src/org/sqlite/jni/WindowFunction.java b/ext/jni/src/org/sqlite/jni/WindowFunction.java index c083312f2..7f70177ac 100644 --- a/ext/jni/src/org/sqlite/jni/WindowFunction.java +++ b/ext/jni/src/org/sqlite/jni/WindowFunction.java @@ -15,11 +15,11 @@ package org.sqlite.jni; /** - An SQLFunction subclass for creating window functions. Note that - Window<T> inherits from Aggregate<T> and each instance is - required to implement the inherited abstract methods from that - class. See Aggregate<T> for information on managing the UDF's - invocation-specific state. + A SQLFunction implementation for window functions. Note that + WindowFunction inherits from {@link AggregateFunction} and each + instance is required to implement the inherited abstract methods + from that class. See {@link AggregateFunction} for information on + managing the UDF's invocation-specific state. */ public abstract class WindowFunction<T> extends AggregateFunction<T> { diff --git a/ext/jni/src/org/sqlite/jni/annotation/Canonical.java b/ext/jni/src/org/sqlite/jni/annotation/Canonical.java index 260fb2df5..f329aee13 100644 --- a/ext/jni/src/org/sqlite/jni/annotation/Canonical.java +++ b/ext/jni/src/org/sqlite/jni/annotation/Canonical.java @@ -2,15 +2,43 @@ package org.sqlite.jni.annotation; /** This annotation is for marking functions as "canonical", meaning - that they exist in the C API. The intent is to distinguish them - from functions added specifically to the Java API. + that they map directly to a function in the core sqlite3 C API. The + intent is to distinguish them from functions added specifically to + the Java API. <p>Canonical functions, unless specifically documented, have the - same semantics as their counterparts in @{link - https://sqlite.org/c3ref/intro.html the C API documentation}, despite - their signatures perhaps differing. + same semantics as their counterparts in + <a href="https://sqlite.org/c3ref/intro.html">the C API documentation</a>, + despite their signatures perhaps differing. The Java API adds a + number of overloads to simplify use, as well as a few Java-specific + functions, and those are never flagged as @Canonical. + + <p>In some cases, the canonical version of a function is private + and exposed to Java via public overloads. + + <p>In rare cases, the Java interface for a canonical function has a + different name than its C counterpart. For such cases, + (cname=the-C-side-name) is passed to this annotation and a + Java-side implementation with a slightly different signature is + added to with the canonical name. As of this writing, that applies + only to {@link org.sqlite.jni.SQLite3Jni#sqlite3_value_text_utf8} + and {@link org.sqlite.jni.SQLite3Jni#sqlite3_column_text_utf8}. + + <p>The comment property can be used to add a comment. */ @java.lang.annotation.Documented @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE) @java.lang.annotation.Target(java.lang.annotation.ElementType.METHOD) -public @interface Canonical{} +public @interface Canonical{ + /** + Java functions which directly map to a canonical function but + change its name for some reason should not the original name + in this property. + */ + String cname() default ""/*doesn't allow null*/; + /** + Brief comments about the binding, e.g. noting any major + semantic differences. + */ + String comment() default ""; +} diff --git a/ext/jni/src/org/sqlite/jni/annotation/NotNull.java b/ext/jni/src/org/sqlite/jni/annotation/NotNull.java index 58431e0d9..99eae7370 100644 --- a/ext/jni/src/org/sqlite/jni/annotation/NotNull.java +++ b/ext/jni/src/org/sqlite/jni/annotation/NotNull.java @@ -2,11 +2,14 @@ package org.sqlite.jni.annotation; /** This annotation is for flagging parameters which may not legally be - null. Note that the C-style API does not throw any exceptions on - its own because it has a no-throw policy in order to retain its - C-style semantics, but it may trigger NullPointerExceptions (or - similar) if passed a null for a parameter flagged with this - annotation. + null. When used in the context of callback methods which are + called into from the C APIs, this annotation communicates that the + C API will never pass a null value to the callback. + + <p>Note that the C-style API does not throw any exceptions on its + own because it has a no-throw policy in order to retain its C-style + semantics, but it may trigger NullPointerExceptions (or similar) if + passed a null for a parameter flagged with this annotation. <p>This annotation is informational only. No policy is in place to programmatically ensure that NotNull is conformed to in client diff --git a/ext/jni/src/org/sqlite/jni/annotation/Nullable.java b/ext/jni/src/org/sqlite/jni/annotation/Nullable.java index 187ab263b..7a011e33b 100644 --- a/ext/jni/src/org/sqlite/jni/annotation/Nullable.java +++ b/ext/jni/src/org/sqlite/jni/annotation/Nullable.java @@ -3,7 +3,10 @@ package org.sqlite.jni.annotation; /** This annotation is for flagging parameters which may legally be null, noting that they may behave differently if passed null but - are prepared to expect null as a value. + are prepared to expect null as a value. When used in the context of + callback methods which are called into from the C APIs, this + annotation communicates that the C API may pass a null value to the + callback. <p>This annotation is solely for the use by the classes in this package but is made public so that javadoc will link to it from the diff --git a/ext/jni/src/org/sqlite/jni/annotation/package-info.java b/ext/jni/src/org/sqlite/jni/annotation/package-info.java new file mode 100644 index 000000000..50db2a32b --- /dev/null +++ b/ext/jni/src/org/sqlite/jni/annotation/package-info.java @@ -0,0 +1,4 @@ +/** + This package houses annotations specific a JNI binding to the SQLite3 C API. +*/ +package org.sqlite.jni.annotation; diff --git a/ext/jni/src/org/sqlite/jni/tester/SQLTester.java b/ext/jni/src/org/sqlite/jni/tester/SQLTester.java index d8b84af79..e355fe760 100644 --- a/ext/jni/src/org/sqlite/jni/tester/SQLTester.java +++ b/ext/jni/src/org/sqlite/jni/tester/SQLTester.java @@ -152,12 +152,12 @@ class Outer { /** This class provides an application which aims to implement the rudimentary SQL-driven test tool described in the accompanying - test-script-interpreter.md. + {@code test-script-interpreter.md}. - This is a work in progress. + <p>This is a work in progress. - An instance of this application provides a core set of services + <p>An instance of this application provides a core set of services which TestScript instances use for processing testing logic. TestScripts, in turn, delegate the concrete test work to Command objects, which the TestScript parses on their behalf. @@ -1,5 +1,5 @@ -C Correct\sa\spackage\srenaming\sbug\sin\sthe\sprevious\scheck-in\sand\sstart\sapplying\sthe\s@Canonical\sannotation\sto\sfunctions\sto\sdistinguish\scanonical\sAPI\sfunctions\sand\sJava-specific\sAPIs. -D 2023-08-28T05:48:34.397 +C Lots\sof\sjavadoc-related\stweaks. +D 2023-08-28T07:28:36.868 F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1 F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea F LICENSE.md df5091916dbb40e6e9686186587125e1b2ff51f022cc334e886c19a0e9982724 @@ -233,18 +233,19 @@ F ext/fts5/tool/showfts5.tcl d54da0e067306663e2d5d523965ca487698e722c F ext/icu/README.txt 7ab7ced8ae78e3a645b57e78570ff589d4c672b71370f5aa9e1cd7024f400fc9 F ext/icu/icu.c c074519b46baa484bb5396c7e01e051034da8884bad1a1cb7f09bbe6be3f0282 F ext/icu/sqliteicu.h fa373836ed5a1ee7478bdf8a1650689294e41d0c89c1daab26e9ae78a32075a8 -F ext/jni/GNUmakefile e582f0e36b80c9588d52f520bf07c37ddbd63199029a97de0925014e73127972 +F ext/jni/GNUmakefile 8bb7f82029eb7d6182f4af9c42f99abaf4cf476984f5aebd6dcf05d85da340c5 F ext/jni/README.md 1332b1fa27918bd5d9ca2d0d4f3ac3a6ab86b9e3699dc5bfe32904a027f3d2a9 F ext/jni/jar-dist.make 030aaa4ae71dd86e4ec5e7c1e6cd86f9dfa47c4592c070d2e35157e42498e1fa -F ext/jni/src/c/sqlite3-jni.c 5d43a4a29d16f6a593091eb60371e166d56d0c019cb75a6b741bc41e3b946344 -F ext/jni/src/c/sqlite3-jni.h a43832a04347433e640f1b135f3a8b2a4293369a963659216c51d04daf934b43 -F ext/jni/src/org/sqlite/jni/AggregateFunction.java 0a5a74bea5ee12a99407e9432d0ca393525af912c2b0ca55c7ee5dbd019c00ef -F ext/jni/src/org/sqlite/jni/AuthorizerCallback.java 91442d9871423d01cb1750d63ccf991b3dadcf0a4efaf1d5bc49696469aeae2f -F ext/jni/src/org/sqlite/jni/AutoExtensionCallback.java 4290d8b0937b07d466b50e6ca4136cec037f3ce658277af0d0c2d371e5f4b459 -F ext/jni/src/org/sqlite/jni/BusyHandlerCallback.java efef1892e404f5780d81c46a7997cab874aff5db5131985dd3af319fc5e3adc7 -F ext/jni/src/org/sqlite/jni/CollationCallback.java 4391351e10f26ca61e9c461f969c12f36e0146e50a8c5b66ff549142bbf41f64 -F ext/jni/src/org/sqlite/jni/CollationNeededCallback.java b2adbe0cb41b67bcb638885e00950abe0265e885326a96451f6ab114fb11ef59 -F ext/jni/src/org/sqlite/jni/CommitHookCallback.java c2b4deec20acf9c72ab487ba1a408c54cb5cc12c45baa46490b555b80bd3579f +F ext/jni/src/c/sqlite3-jni.c 064d3a14650221582a1d1621bd1109efb2a455f556387613cd583731eac28674 +F ext/jni/src/c/sqlite3-jni.h 12e1a5ef5ee1795dc22577c285b4518dfd8aa4af45757f6cb81a555d967bf201 +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 d00a2409ab76cae168927e2ca6a7ffbd0621a42547cce88768b4eeebc13827e0 +F ext/jni/src/org/sqlite/jni/AutoExtensionCallback.java 1470e14d09f10729d35568506c6e61318edfb17aa322802e386764fa6d582f14 +F ext/jni/src/org/sqlite/jni/BusyHandlerCallback.java cd12c26dafd3e6c097fc73f80d328aebac0f58b985f66a96ee567ddf8d195f30 +F ext/jni/src/org/sqlite/jni/CollationCallback.java 7d5b246f1a7c9d6b8e974d970bbbb2d05c6264e65448d7be6a85edbf703c823d +F ext/jni/src/org/sqlite/jni/CollationNeededCallback.java 1707b50146c6b805b79e84f89a57c8dbb0134e431799f041f0bec403eca5f841 +F ext/jni/src/org/sqlite/jni/CommitHookCallback.java e4de82c97560982e996e358958268e1e4e307b6115cd9aac0ff4f947d4380d90 F ext/jni/src/org/sqlite/jni/ConfigSqllogCallback.java e3656909eab7ed0f7e457c5b82df160ca22dd5e954c0a306ec1fca61b0d266b4 F ext/jni/src/org/sqlite/jni/Fts5.java 3ebfbd5b95fdb9d7bc40306f2e682abd12e247d9224e92510b8dd103b4f96fe8 F ext/jni/src/org/sqlite/jni/Fts5Context.java 0a5a02047a6a1dd3e4a38b0e542a8dd2de365033ba30e6ae019a676305959890 @@ -254,24 +255,25 @@ F ext/jni/src/org/sqlite/jni/Fts5PhraseIter.java 6642beda341c0b1b46af4e2d7f6f9ab 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 4ae06135decef35eb04498daa2868939d91a294e948747c580ef9ce31563a6b3 -F ext/jni/src/org/sqlite/jni/PreupdateHookCallback.java 8925c58797a90caeb4a7728a964227db3ba6f953cc89b8be38a5ae6fea063818 -F ext/jni/src/org/sqlite/jni/ProgressHandlerCallback.java 7c46660c6b07a765a3f053ae06a10d7ccb4966b49979143d605a3bfb4f14f806 +F ext/jni/src/org/sqlite/jni/PreupdateHookCallback.java 500c968b3893edbddf67e8eb773852c3a8ae58097a77bd22320ada6b1af06db1 +F ext/jni/src/org/sqlite/jni/ProgressHandlerCallback.java 0da841810319f5a9dc372d0f2348930d54fac1a4b53e4298884f44c720d67830 F ext/jni/src/org/sqlite/jni/ResultCode.java ba701f20213a5f259e94cfbfdd36eb7ac7ce7797f2c6c7fca2004ff12ce20f86 -F ext/jni/src/org/sqlite/jni/RollbackHookCallback.java be7f7a26d1102fb514d835e11198d51302af8053d97188bfb2e34c2133208568 -F ext/jni/src/org/sqlite/jni/SQLFunction.java d060f302b2cc4cf7a4f5a6b2d36458a2e6fc9648374b5d09c36a43665af41207 -F ext/jni/src/org/sqlite/jni/SQLite3CallbackProxy.java 13c4ea6f35871261eba63fa4117715515e0beecbdebfb879ec5b1f340ed36904 -F ext/jni/src/org/sqlite/jni/SQLite3Jni.java 953288346d99520bbc9ec94a28ec3a47262ef0c81fc7b11d82f8ba5143589518 -F ext/jni/src/org/sqlite/jni/ScalarFunction.java 21301a947e49f0dd9c682dfe2cc8a6518226c837253dd791cd512f847eeca52c +F ext/jni/src/org/sqlite/jni/RollbackHookCallback.java 16042be9d072a26dbb2f1b1b63e7639989b747bb80d2bd667ba4f7555f56a825 +F ext/jni/src/org/sqlite/jni/SQLFunction.java 544a875d33fd160467d82e2397ac33157b29971d715a821a4fad3c899113ee8c +F ext/jni/src/org/sqlite/jni/SQLite3CallbackProxy.java c2748ab52856075b053a55b317988d95dc7fb4d3d42520f8c33573effe1cd185 +F ext/jni/src/org/sqlite/jni/SQLite3Jni.java 54b39846ee0540f8d8fc700739cd6701ba1231e12c3964c1d367b51e9315ed3b +F ext/jni/src/org/sqlite/jni/ScalarFunction.java 6d387bb499fbe3bc13c53315335233dbf6a0c711e8fa7c521683219b041c614c F ext/jni/src/org/sqlite/jni/Tester1.java 8653c7b0b50116cf9bd8bf19b83b3e76896b75df09f5debe57a70c556d90203b F ext/jni/src/org/sqlite/jni/TesterFts5.java 6f135c60e24c89e8eecb9fe61dde0f3bb2906de668ca6c9186bcf34bdaf94629 -F ext/jni/src/org/sqlite/jni/TraceV2Callback.java 25a45e800b0c57f506c237d111bcfd09da584e936fee395d4bd802100ebeff8c -F ext/jni/src/org/sqlite/jni/UpdateHookCallback.java f5eadfa44462c050658230884b41477274f34306accd85c8201a7afbc00d2429 +F ext/jni/src/org/sqlite/jni/TraceV2Callback.java 641926b05a772c2c05c842a81aa839053ba4a13b78ef04b402f5705d060c6246 +F ext/jni/src/org/sqlite/jni/UpdateHookCallback.java be2bc96ff4f56b3c1fd18ae7dba9b207b25b6c123b8a5fd2f7aaf3cc208d8b7d F ext/jni/src/org/sqlite/jni/ValueHolder.java f022873abaabf64f3dd71ab0d6037c6e71cece3b8819fa10bf26a5461dc973ee -F ext/jni/src/org/sqlite/jni/WindowFunction.java 3e24a0f2615f9a232b1ecbb3f243b05dd7c007dc43be238499af93a459fe8253 +F ext/jni/src/org/sqlite/jni/WindowFunction.java 488980f4dbb6bdd7067d6cb9c43e4075475e51c54d9b74a5834422654b126246 F ext/jni/src/org/sqlite/jni/XDestroyCallback.java 95fb66353e62e4aca8d6ab60e8f14f9235bd10373c34db0a64f5f13f016f0471 -F ext/jni/src/org/sqlite/jni/annotation/Canonical.java 87e59ab0ee5e454bc8b6a6e659996b2141041dd46e71638b42baf3360a990126 -F ext/jni/src/org/sqlite/jni/annotation/NotNull.java 3a105502c56c0e4f1a826122db356be713cda975b3c17877d0805e45652f5937 -F ext/jni/src/org/sqlite/jni/annotation/Nullable.java 38a2cf9b780484ca7950b76445f65133463afba6d593fd8d4a381a5937135b1c +F ext/jni/src/org/sqlite/jni/annotation/Canonical.java e55b82c8259b617ff754ac493fd8b79602631d659b87a858b987540e4c4fdf56 +F ext/jni/src/org/sqlite/jni/annotation/NotNull.java d48ebd7ae6bbb78bd47d54431c85e1521c89b1d3864a2b6eafd9c0e1b2341457 +F ext/jni/src/org/sqlite/jni/annotation/Nullable.java 6f962a98c9a5c6e9d21c50ae8716b16bdfdc934a191608cbb7e12ea588ddb6af +F ext/jni/src/org/sqlite/jni/annotation/package-info.java f66bfb621c6494e67c03ed38a9e26a3bd6af99b9f9f6ef79556bcec30a025a22 F ext/jni/src/org/sqlite/jni/fts5_api.java ee47f1837d32968f7bb62278c7504c0fb572a68ec107371b714578312e9f734b F ext/jni/src/org/sqlite/jni/fts5_extension_function.java ac825035d7d83fc7fd960347abfa6803e1614334a21533302041823ad5fc894c F ext/jni/src/org/sqlite/jni/fts5_tokenizer.java a92c2e55bda492e4c76d48ddc73369bcc0d5e8727940840f9339e3292ea58fa7 @@ -280,7 +282,7 @@ F ext/jni/src/org/sqlite/jni/sqlite3.java 62b1b81935ccf3393472d17cb883dc5ff39c38 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 -F ext/jni/src/org/sqlite/jni/tester/SQLTester.java 439d28ac92570e4d16a5361423656f3eae6916c6d4777afde490f77dbb3ec1bc +F ext/jni/src/org/sqlite/jni/tester/SQLTester.java bf350903abe04a9bed2d8a2a71692ed4291dbb4eece2d3329ed91d15b0321e6d F ext/jni/src/org/sqlite/jni/tester/test-script-interpreter.md f9f25126127045d051e918fe59004a1485311c50a13edbf18c79a6ff9160030e F ext/jni/src/tests/000-000-sanity.test cfe6dc1b950751d6096e3f5695becaadcdaa048bfe9567209d6eb676e693366d F ext/jni/src/tests/000-001-ignored.test e17e874c6ab3c437f1293d88093cf06286083b65bf162317f91bbfd92f961b70 @@ -2104,8 +2106,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 e4dedf90a92a069daef967dfe975469bf8ec7883c44c95e73345d4eded48e996 -R 2d3e956453c21ac2865e49e96e7183c2 +P 8a016006805b08b72bfc4093c795d8cd8d7fe72f8ae234c175a8b7be3a841cbf +R 9e09f148c76497a018ec611f2deafbbd U stephan -Z 2de3d392080a8d73c4c451d28e259756 +Z cceffc0e8c2aa755651a9db7f05913c5 # Remove this line to create a well-formed Fossil manifest. diff --git a/manifest.uuid b/manifest.uuid index da3d87c08..ce51adc40 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -8a016006805b08b72bfc4093c795d8cd8d7fe72f8ae234c175a8b7be3a841cbf
\ No newline at end of file +cfe06f90e2c0231efded98767ef3cc646d3a7daa34d77b62b7c04b5aae9448fd
\ No newline at end of file |