mirrors/sqlite
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Lots of javadoc-related tweaks.

Browse Source 
FossilOrigin-Name: cfe06f90e2c0231efded98767ef3cc646d3a7daa34d77b62b7c04b5aae9448fd
This commit is contained in:
stephan 2023-08-28 07:28:36 +00:00
parent 23dfa67c1e
commit 2597ec6385
28 changed files with 342 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ext/jni/GNUmakefile
View File

@ -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

9
ext/jni/src/c/sqlite3-jni.c
View File

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

8
ext/jni/src/c/sqlite3-jni.h
View File

@ -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

34
ext/jni/src/org/sqlite/jni/AbstractCollationCallback.java Normal file
View File

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

8
ext/jni/src/org/sqlite/jni/AggregateFunction.java
View File

@ -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

4
ext/jni/src/org/sqlite/jni/AuthorizerCallback.java
View File

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

17
ext/jni/src/org/sqlite/jni/AutoExtensionCallback.java
View File

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

10
ext/jni/src/org/sqlite/jni/BusyHandlerCallback.java
View File

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

16
ext/jni/src/org/sqlite/jni/CollationCallback.java
View File

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

2
ext/jni/src/org/sqlite/jni/CollationNeededCallback.java
View File

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

2
ext/jni/src/org/sqlite/jni/CommitHookCallback.java
View File

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

4
ext/jni/src/org/sqlite/jni/PreupdateHookCallback.java
View File

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

4
ext/jni/src/org/sqlite/jni/ProgressHandlerCallback.java
View File

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

4
ext/jni/src/org/sqlite/jni/RollbackHookCallback.java
View File

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

10
ext/jni/src/org/sqlite/jni/SQLFunction.java
View File

@ -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

24
ext/jni/src/org/sqlite/jni/SQLite3CallbackProxy.java
View File

@ -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 {}

140
ext/jni/src/org/sqlite/jni/SQLite3Jni.java
View File

@ -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
){
final byte[] ba = sqlite3_column_text_utf8(stmt, ndx);
return ba==null ? null : new String(ba, StandardCharsets.UTF_8);
}
/**
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
);
@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);
/**

6
ext/jni/src/org/sqlite/jni/ScalarFunction.java
View File

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

7
ext/jni/src/org/sqlite/jni/TraceV2Callback.java
View File

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

4
ext/jni/src/org/sqlite/jni/UpdateHookCallback.java
View File

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

10
ext/jni/src/org/sqlite/jni/WindowFunction.java
View File

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

40
ext/jni/src/org/sqlite/jni/annotation/Canonical.java
View File

@ -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 "";
}

13
ext/jni/src/org/sqlite/jni/annotation/NotNull.java
View File

@ -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

5
ext/jni/src/org/sqlite/jni/annotation/Nullable.java
View File

@ -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

4
ext/jni/src/org/sqlite/jni/annotation/package-info.java Normal file
View File

@ -0,0 +1,4 @@
/**
This package houses annotations specific a JNI binding to the SQLite3 C API.
*/
package org.sqlite.jni.annotation;

6
ext/jni/src/org/sqlite/jni/tester/SQLTester.java
View File

@ -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.

60
manifest
View File

@ -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.

2
manifest.uuid
View File

@ -1 +1 @@
8a016006805b08b72bfc4093c795d8cd8d7fe72f8ae234c175a8b7be3a841cbf
cfe06f90e2c0231efded98767ef3cc646d3a7daa34d77b62b7c04b5aae9448fd