Lots of javadoc-related tweaks.

FossilOrigin-Name: cfe06f90e2c0231efded98767ef3cc646d3a7daa34d77b62b7c04b5aae9448fd

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

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
 ){

ext/jni/src/c/sqlite3-jni.h

@@ -1043,6 +1043,14 @@ JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1table_
 JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1text_1utf8
   (JNIEnv *, jclass, jobject, jint);
 
+/*
+ * 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

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(){}
+}

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
+   A SQLFunction implementation for aggregate functions.  Its T is the
-   the data type of its "accumulator" state, an instance of which is
+   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

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);

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
+   Callback for use with the {@link SQLite3Jni#sqlite3_auto_extension}
-   APIs.
+   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
+     sqlite3_auto_extension() callback.
-     signature is shorter.
 
-     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);
 }

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);
 }

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
+public interface CollationCallback
-  implements SQLite3CallbackProxy, XDestroyCallback {
+  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();
 }

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 {
   /**

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 {
   /**

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 );

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();

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();
 }

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 -
+     <p>This class is a helper providing commonly-needed functionality
-     it is not required for use with aggregate or window functions.
+     - 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
+     approaches. The provided {@link AggregateFunction} and {@link
-     use this.
+     WindowFunction} classes use this.
   */
   public static final class PerContextState<T> {
     private final java.util.Map<Long,ValueHolder<T>> map

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
+   proxying for, minus the {@code sqlite3_} prefix, plus a {@code
-   suffix. e.g. sqlite3_busy_handler()'s callback is named
+   Callback} suffix. e.g. {@code sqlite3_busy_handler()}'s callback is
-   BusyHandlerCallback. Exceptions are made where that would
+   named {@code BusyHandlerCallback}. Exceptions are made where that
-   potentially be ambiguous, e.g. ConfigSqllogCallback instead of
+   would potentially be ambiguous, e.g. {@link ConfigSqllogCallback}
-   config_callback because the sqlite3_config() interface may need to
+   instead of {@code ConfigCallback} because the {@code
-   support more callback types in the future.
+   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 {}

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(
+  /**
-    @NotNull sqlite3_stmt stmt, int ndx
+     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.
-    final byte[] ba = sqlite3_column_text_utf8(stmt, ndx);
-    return ba==null ? null : new String(ba, StandardCharsets.UTF_8);
-  }
 
+     @see #sqlite3_column_text16
+  */
+  public static native String sqlite3_column_text(
+    @NotNull sqlite3_stmt stmt, int ndx
+  );
+
+  @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);
 
   /**

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() {}
 }

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);
 }

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);
 }

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
+   A SQLFunction implementation for window functions.  Note that
-   Window<T> inherits from Aggregate<T> and each instance is
+   WindowFunction inherits from {@link AggregateFunction} and each
-   required to implement the inherited abstract methods from that
+   instance is required to implement the inherited abstract methods
-   class. See Aggregate<T> for information on managing the UDF's
+   from that class. See {@link AggregateFunction} for information on
-   invocation-specific state.
+   managing the UDF's invocation-specific state.
 */
 public abstract class WindowFunction<T> extends AggregateFunction<T> {
 

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
+   that they map directly to a function in the core sqlite3 C API. The
-   from functions added specifically to the Java API.
+   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
+   same semantics as their counterparts in
-   https://sqlite.org/c3ref/intro.html the C API documentation}, despite
+   <a href="https://sqlite.org/c3ref/intro.html">the C API documentation</a>,
-   their signatures perhaps differing.
+   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 "";
+}

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
+   null.  When used in the context of callback methods which are
-   its own because it has a no-throw policy in order to retain its
+   called into from the C APIs, this annotation communicates that the
-   C-style semantics, but it may trigger NullPointerExceptions (or
+   C API will never pass a null value to the callback.
-   similar) if passed a null for a parameter flagged with this
+
-   annotation.
+   <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

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

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;

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.

manifest

@@ -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.
+C Lots\sof\sjavadoc-related\stweaks.
-D 2023-08-28T05:48:34.397
+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.c 064d3a14650221582a1d1621bd1109efb2a455f556387613cd583731eac28674
-F ext/jni/src/c/sqlite3-jni.h a43832a04347433e640f1b135f3a8b2a4293369a963659216c51d04daf934b43
+F ext/jni/src/c/sqlite3-jni.h 12e1a5ef5ee1795dc22577c285b4518dfd8aa4af45757f6cb81a555d967bf201
-F ext/jni/src/org/sqlite/jni/AggregateFunction.java 0a5a74bea5ee12a99407e9432d0ca393525af912c2b0ca55c7ee5dbd019c00ef
+F ext/jni/src/org/sqlite/jni/AbstractCollationCallback.java 95e88ba04f4aac51ffec65693e878e234088b2f21b387f4e4285c8b72b33e436
-F ext/jni/src/org/sqlite/jni/AuthorizerCallback.java 91442d9871423d01cb1750d63ccf991b3dadcf0a4efaf1d5bc49696469aeae2f
+F ext/jni/src/org/sqlite/jni/AggregateFunction.java 7312486bc65fecdb91753c0a4515799194e031f45edbe16a6373cea18f404dc4
-F ext/jni/src/org/sqlite/jni/AutoExtensionCallback.java 4290d8b0937b07d466b50e6ca4136cec037f3ce658277af0d0c2d371e5f4b459
+F ext/jni/src/org/sqlite/jni/AuthorizerCallback.java d00a2409ab76cae168927e2ca6a7ffbd0621a42547cce88768b4eeebc13827e0
-F ext/jni/src/org/sqlite/jni/BusyHandlerCallback.java efef1892e404f5780d81c46a7997cab874aff5db5131985dd3af319fc5e3adc7
+F ext/jni/src/org/sqlite/jni/AutoExtensionCallback.java 1470e14d09f10729d35568506c6e61318edfb17aa322802e386764fa6d582f14
-F ext/jni/src/org/sqlite/jni/CollationCallback.java 4391351e10f26ca61e9c461f969c12f36e0146e50a8c5b66ff549142bbf41f64
+F ext/jni/src/org/sqlite/jni/BusyHandlerCallback.java cd12c26dafd3e6c097fc73f80d328aebac0f58b985f66a96ee567ddf8d195f30
-F ext/jni/src/org/sqlite/jni/CollationNeededCallback.java b2adbe0cb41b67bcb638885e00950abe0265e885326a96451f6ab114fb11ef59
+F ext/jni/src/org/sqlite/jni/CollationCallback.java 7d5b246f1a7c9d6b8e974d970bbbb2d05c6264e65448d7be6a85edbf703c823d
-F ext/jni/src/org/sqlite/jni/CommitHookCallback.java c2b4deec20acf9c72ab487ba1a408c54cb5cc12c45baa46490b555b80bd3579f
+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/PreupdateHookCallback.java 500c968b3893edbddf67e8eb773852c3a8ae58097a77bd22320ada6b1af06db1
-F ext/jni/src/org/sqlite/jni/ProgressHandlerCallback.java 7c46660c6b07a765a3f053ae06a10d7ccb4966b49979143d605a3bfb4f14f806
+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/RollbackHookCallback.java 16042be9d072a26dbb2f1b1b63e7639989b747bb80d2bd667ba4f7555f56a825
-F ext/jni/src/org/sqlite/jni/SQLFunction.java d060f302b2cc4cf7a4f5a6b2d36458a2e6fc9648374b5d09c36a43665af41207
+F ext/jni/src/org/sqlite/jni/SQLFunction.java 544a875d33fd160467d82e2397ac33157b29971d715a821a4fad3c899113ee8c
-F ext/jni/src/org/sqlite/jni/SQLite3CallbackProxy.java 13c4ea6f35871261eba63fa4117715515e0beecbdebfb879ec5b1f340ed36904
+F ext/jni/src/org/sqlite/jni/SQLite3CallbackProxy.java c2748ab52856075b053a55b317988d95dc7fb4d3d42520f8c33573effe1cd185
-F ext/jni/src/org/sqlite/jni/SQLite3Jni.java 953288346d99520bbc9ec94a28ec3a47262ef0c81fc7b11d82f8ba5143589518
+F ext/jni/src/org/sqlite/jni/SQLite3Jni.java 54b39846ee0540f8d8fc700739cd6701ba1231e12c3964c1d367b51e9315ed3b
-F ext/jni/src/org/sqlite/jni/ScalarFunction.java 21301a947e49f0dd9c682dfe2cc8a6518226c837253dd791cd512f847eeca52c
+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/TraceV2Callback.java 641926b05a772c2c05c842a81aa839053ba4a13b78ef04b402f5705d060c6246
-F ext/jni/src/org/sqlite/jni/UpdateHookCallback.java f5eadfa44462c050658230884b41477274f34306accd85c8201a7afbc00d2429
+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/Canonical.java e55b82c8259b617ff754ac493fd8b79602631d659b87a858b987540e4c4fdf56
-F ext/jni/src/org/sqlite/jni/annotation/NotNull.java 3a105502c56c0e4f1a826122db356be713cda975b3c17877d0805e45652f5937
+F ext/jni/src/org/sqlite/jni/annotation/NotNull.java d48ebd7ae6bbb78bd47d54431c85e1521c89b1d3864a2b6eafd9c0e1b2341457
-F ext/jni/src/org/sqlite/jni/annotation/Nullable.java 38a2cf9b780484ca7950b76445f65133463afba6d593fd8d4a381a5937135b1c
+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
+P 8a016006805b08b72bfc4093c795d8cd8d7fe72f8ae234c175a8b7be3a841cbf
-R 2d3e956453c21ac2865e49e96e7183c2
+R 9e09f148c76497a018ec611f2deafbbd
 U stephan
-Z 2de3d392080a8d73c4c451d28e259756
+Z cceffc0e8c2aa755651a9db7f05913c5
 # Remove this line to create a well-formed Fossil manifest.

manifest.uuid

@@ -1 +1 @@
-8a016006805b08b72bfc4093c795d8cd8d7fe72f8ae234c175a8b7be3a841cbf
+cfe06f90e2c0231efded98767ef3cc646d3a7daa34d77b62b7c04b5aae9448fd