diff options
Diffstat (limited to 'ext')
17 files changed, 1261 insertions, 759 deletions
diff --git a/ext/jni/GNUmakefile b/ext/jni/GNUmakefile index ddf97dd8a..942a4a96d 100644 --- a/ext/jni/GNUmakefile +++ b/ext/jni/GNUmakefile @@ -26,8 +26,8 @@ dir.src.c := $(dir.src)/c dir.bld := $(dir.jni)/bld dir.bld.c := $(dir.bld) dir.src.jni := $(dir.src)/org/sqlite/jni -dir.src.jni.tester := $(dir.src.jni)/tester dir.src.fts5 := $(dir.src.jni)/fts5 +dir.tests := $(dir.src)/tests mkdir ?= mkdir -p $(dir.bld.c): $(mkdir) $@ @@ -46,7 +46,7 @@ DISTCLEAN_FILES := $(dir.jni)/*~ $(dir.src.c)/*~ $(dir.src.jni)/*~ sqlite3-jni.h := $(dir.src.c)/sqlite3-jni.h .NOTPARALLEL: $(sqlite3-jni.h) SQLite3Jni.java := src/org/sqlite/jni/SQLite3Jni.java -SQLTester.java := src/org/sqlite/jni/tester/SQLTester.java +SQLTester.java := src/org/sqlite/jni/SQLTester.java SQLite3Jni.class := $(SQLite3Jni.java:.java=.class) SQLTester.class := $(SQLTester.java:.java=.class) @@ -61,8 +61,12 @@ SQLTester.class := $(SQLTester.java:.java=.class) # which the fts5 APIs have been stripped unless that feature is # intended to be stripped for good. enable.fts5 ?= 1 -# If enable.tester is 0, the org/sqlite/jni/tester/* bits are elided. -enable.tester ?= $(if $(wildcard $(dir.src.jni.tester)/SQLTester.java),1,0) + +ifeq (,$(wildcard $(dir.tests)/*)) + enable.tester := 0 +else + enable.tester := 1 +endif # bin.version-info = binary to output various sqlite3 version info # building the distribution zip file. @@ -112,6 +116,9 @@ JAVA_FILES.unittest := $(patsubst %,$(dir.src.jni)/%,\ Tester1.java \ ) ifeq (1,$(enable.fts5)) + JAVA_FILES.unittest += $(patsubst %,$(dir.src.jni)/%,\ + TesterFts5.java \ + ) JAVA_FILES.main += $(patsubst %,$(dir.src.fts5)/%,\ fts5_api.java \ fts5_extension_function.java \ @@ -121,11 +128,10 @@ ifeq (1,$(enable.fts5)) Fts5ExtensionApi.java \ Fts5PhraseIter.java \ Fts5Tokenizer.java \ - TesterFts5.java \ XTokenizeCallback.java \ ) endif -JAVA_FILES.tester := $(dir.src.jni.tester)/SQLTester.java +JAVA_FILES.tester := $(SQLTester.java) JAVA_FILES.package.info := \ $(dir.src.jni)/package-info.java \ $(dir.src.jni)/annotation/package-info.java @@ -233,14 +239,12 @@ endef # Invoke ADD_JNI_H once for each Java file which includes JNI # declarations: $(eval $(call ADD_JNI_H,$(dir.src.jni),SQLite3Jni,)) +$(eval $(call ADD_JNI_H,$(dir.src.jni),SQLTester,)) ifeq (1,$(enable.fts5)) $(eval $(call ADD_JNI_H,$(dir.src.fts5),Fts5ExtensionApi,_fts5)) $(eval $(call ADD_JNI_H,$(dir.src.fts5),fts5_api,_fts5)) $(eval $(call ADD_JNI_H,$(dir.src.fts5),fts5_tokenizer,_fts5)) endif -ifeq (1,$(enable.tester)) - $(eval $(call ADD_JNI_H,$(dir.src.jni.tester),SQLTester,_tester)) -endif $(sqlite3-jni.h.in): $(dir.bld.c) #package.dll.cfiles := @@ -252,17 +256,18 @@ package.dll.cflags = \ -I$(JDK_HOME)/include \ $(patsubst %,-I%,$(patsubst %.h,,$(wildcard $(JDK_HOME)/include/*))) \ -Wall -# Using (-Wall -Wextra) triggers an untennable number of -# gcc warnings from sqlite3.c for mundane things like -# unused parameters. -# # The gross $(patsubst...) above is to include the platform-specific # subdir which lives under $(JDK_HOME)/include and is a required # include path for client-level code. +# +# Using (-Wall -Wextra) triggers an untennable number of +# gcc warnings from sqlite3.c for mundane things like +# unused parameters. ######################################################################## ifeq (1,$(enable.tester)) package.dll.cflags += -DSQLITE_JNI_ENABLE_SQLTester endif + $(sqlite3-jni.h): $(sqlite3-jni.h.in) $(MAKEFILE) @cat $(sqlite3-jni.h.in) > $@.tmp @if cmp $@ $@.tmp >/dev/null; then \ @@ -308,21 +313,21 @@ ifeq (1,$(enable.tester)) tester-local: $(CLASS_FILES.tester) $(package.dll) $(bin.java) -ea -Djava.library.path=$(dir.bld.c) \ $(java.flags) -cp $(classpath) \ - org.sqlite.jni.tester.SQLTester $(tester.flags) $(tester.scripts) + org.sqlite.jni.SQLTester $(tester.flags) $(tester.scripts) tester: tester-local else tester: - @echo "SQLTester support is disabled. Build with enable.tester=1 to enable it." + @echo "SQLTester support is disabled." endif -tester.extdir.default := src/tests/ext +tester.extdir.default := $(dir.tests)/ext tester.extdir ?= $(tester.extdir.default) tester.extern-scripts := $(wildcard $(tester.extdir)/*.test) ifneq (,$(tester.extern-scripts)) tester-ext: $(bin.java) -ea -Djava.library.path=$(dir.bld.c) \ $(java.flags) -cp $(classpath) \ - org.sqlite.jni.tester.SQLTester $(tester.flags) $(tester.extern-scripts) + org.sqlite.jni.SQLTester $(tester.flags) $(tester.extern-scripts) else tester-ext: @echo "******************************************************"; \ @@ -381,8 +386,7 @@ run-jar: $(package.jar) $(package.dll) # javadoc... dir.doc := $(dir.jni)/javadoc doc.index := $(dir.doc)/index.html -javadoc.exclude := -exclude org.sqlite.jni.tester \ - -exclude org.sqlite.jni.fts5 +javadoc.exclude := -exclude org.sqlite.jni.fts5 # ^^^^ 2023-09-13: elide the fts5 parts from the public docs for # the time being, as it's not clear where the Java bindings for # those bits are going. diff --git a/ext/jni/src/c/sqlite3-jni.c b/ext/jni/src/c/sqlite3-jni.c index a35d9b81c..4161d503f 100644 --- a/ext/jni/src/c/sqlite3-jni.c +++ b/ext/jni/src/c/sqlite3-jni.c @@ -811,13 +811,13 @@ static void s3jni_incr( volatile unsigned int * const p ){ #endif /* Helpers for jstring and jbyteArray. */ -static const char * s3jni__jstring_to_mutf8_bytes(JNIEnv * const env, jstring v ){ +static const char * s3jni__jstring_to_mutf8(JNIEnv * const env, jstring v ){ const char *z = v ? (*env)->GetStringUTFChars(env, v, NULL) : 0; s3jni_oom_check( v ? !!z : !z ); return z; } -#define s3jni_jstring_to_mutf8(ARG) s3jni__jstring_to_mutf8_bytes(env, (ARG)) +#define s3jni_jstring_to_mutf8(ARG) s3jni__jstring_to_mutf8(env, (ARG)) #define s3jni_mutf8_release(ARG,VAR) if( VAR ) (*env)->ReleaseStringUTFChars(env, ARG, VAR) static jbyte * s3jni__jbyteArray_bytes(JNIEnv * const env, jbyteArray jBA ){ @@ -1176,6 +1176,8 @@ static void S3JniHook__unref(JNIEnv * const env, S3JniHook * const s){ } S3JniUnrefGlobal(s->jObj); S3JniUnrefGlobal(s->jExtra); + }else{ + assert( !s->jExtra ); } *s = S3JniHook_empty; } @@ -1183,8 +1185,8 @@ static void S3JniHook__unref(JNIEnv * const env, S3JniHook * const s){ /* ** Allocates one blank S3JniHook object from the recycling bin, if -** available, else from the heap. Returns NULL or dies on OOM. Locks -** the global mutex. +** available, else from the heap. Returns NULL or dies on OOM, +** depending on build options. Locks on SJG.hooks.mutex. */ static S3JniHook *S3JniHook__alloc(JNIEnv * const env){ S3JniHook * p = 0; @@ -1211,7 +1213,7 @@ static S3JniHook *S3JniHook__alloc(JNIEnv * const env){ /* ** The rightful fate of all results from S3JniHook_alloc(). Locks on -** SJG>hooks.mutex. +** SJG.hook.mutex. */ static void S3JniHook__free(JNIEnv * const env, S3JniHook * const p){ if(p){ @@ -1290,10 +1292,11 @@ static void S3JniDb__set_aside(JNIEnv * const env, S3JniDb * const s){ /* ** Uncache any state for the given JNIEnv, clearing all Java ** references the cache owns. Returns true if env was cached and false -** if it was not found in the cache. Ownership of the given object is -** passed over to this function, which makes it free for re-use. +** if it was not found in the cache. Ownership of the S3JniEnv object +** associated with the given argument is transferred to this function, +** which makes it free for re-use. ** -** Requires that the Env mutex be locked. +** Requires that the env mutex be locked. */ static int S3JniEnv_uncache(JNIEnv * const env){ struct S3JniEnv * row; @@ -1307,7 +1310,7 @@ static int S3JniEnv_uncache(JNIEnv * const env){ } } if( !row ){ - return 0; + return 0; } if( pPrev) pPrev->pNext = row->pNext; else{ @@ -1440,29 +1443,27 @@ static void * NativePointerHolder__get(JNIEnv * env, jobject jNph, #define PtrGet_sqlite3_context(OBJ) PtrGet_T(sqlite3_context, OBJ) #define PtrGet_sqlite3_stmt(OBJ) PtrGet_T(sqlite3_stmt, OBJ) #define PtrGet_sqlite3_value(OBJ) PtrGet_T(sqlite3_value, OBJ) - -#if 0 /* -** Enters the S3JniDb mutex and PtrGet_sqlite3()'s jObj. If that's -** NULL then it leaves the mutex, else the mutex is still entered -** when this returns and the caller is obligated to leave it. +** S3JniLongPtr_T(X,Y) expects X to be an unqualified sqlite3 +** struct type name and Y to be a native pointer to such an object in +** the form of a jlong value. The jlong is simply cast to (X*). This +** approach is, as of 2023-09-27, supplanting the former approach. We +** now do the native pointer extraction in the Java side, rather than +** the C side, because it's reportedly significantly faster. */ -static sqlite3* PtrGet__sqlite3_lock(JNIEnv * const env, jobject jObj){ - sqlite3 *rv; - S3JniDb_mutex_enter; - rv = PtrGet_sqlite3(jObj); - if( !rv ){ S3JniDb_mutex_leave; } - return rv; -} -#undef PtrGet_sqlite3 -#define PtrGet_sqlite3(JOBJ) PtrGet__sqlite3_lock(env, (JOBJ)) -#endif +#define S3JniLongPtr_T(T,JLongPtr) (T*)(JLongPtr) +#define S3JniLongPtr_sqlite3(JLongPtr) S3JniLongPtr_T(sqlite3,JLongPtr) +#define S3JniLongPtr_sqlite3_backup(JLongPtr) S3JniLongPtr_T(sqlite3_backup,JLongPtr) +#define S3JniLongPtr_sqlite3_blob(JLongPtr) S3JniLongPtr_T(sqlite3_blob,JLongPtr) +#define S3JniLongPtr_sqlite3_stmt(JLongPtr) S3JniLongPtr_T(sqlite3_stmt,JLongPtr) +#define S3JniLongPtr_sqlite3_value(JLongPtr) S3JniLongPtr_T(sqlite3_value,JLongPtr) /* ** Extracts the new S3JniDb instance from the free-list, or allocates -** one if needed, associats it with pDb, and returns. Returns NULL on -** OOM. pDb MUST, on success of the calling operation, subsequently be -** associated with jDb via NativePointerHolder_set(). +** one if needed, associates it with pDb, and returns. Returns NULL +** on OOM. The returned object MUST, on success of the calling +** operation, subsequently be associated with jDb via +** NativePointerHolder_set() or freed using S3JniDb_set_aside(). */ static S3JniDb * S3JniDb_alloc(JNIEnv * const env, jobject jDb){ S3JniDb * rv = 0; @@ -1475,7 +1476,7 @@ static S3JniDb * S3JniDb_alloc(JNIEnv * const env, jobject jDb){ } S3JniDb_mutex_leave; if( 0==rv ){ - rv = s3jni_malloc( sizeof(S3JniDb)); + rv = s3jni_malloc(sizeof(S3JniDb)); if( rv ){ s3jni_incr( &SJG.metrics.nPdbAlloc ); } @@ -1514,6 +1515,8 @@ static void S3JniDb_xDestroy(void *p){ */ #define S3JniDb_from_c(sqlite3Ptr) \ ((sqlite3Ptr) ? S3JniDb_from_clientdata(sqlite3Ptr) : 0) +#define S3JniDb_from_jlong(sqlite3PtrAsLong) \ + S3JniDb_from_c(S3JniLongPtr_T(sqlite3,sqlite3PtrAsLong)) /* ** Unref any Java-side state in (S3JniAutoExtension*) AX and zero out @@ -1992,51 +1995,48 @@ static void udf_xInverse(sqlite3_context* cx, int argc, return rv; \ } /** Create a trivial JNI wrapper for (int CName(sqlite3_stmt*)). */ -#define WRAP_INT_STMT(JniNameSuffix,CName) \ - JniDecl(jint,JniNameSuffix)(JniArgsEnvClass, jobject jpStmt){ \ - jint const rc = (jint)CName(PtrGet_sqlite3_stmt(jpStmt)); \ - S3JniExceptionIgnore /* squelch -Xcheck:jni */; \ - return rc; \ +#define WRAP_INT_STMT(JniNameSuffix,CName) \ + JniDecl(jint,JniNameSuffix)(JniArgsEnvClass, jlong jpStmt){ \ + return (jint)CName(S3JniLongPtr_sqlite3_stmt(jpStmt)); \ } /** Create a trivial JNI wrapper for (int CName(sqlite3_stmt*,int)). */ #define WRAP_INT_STMT_INT(JniNameSuffix,CName) \ - JniDecl(jint,JniNameSuffix)(JniArgsEnvClass, jobject pStmt, jint n){ \ - return (jint)CName(PtrGet_sqlite3_stmt(pStmt), (int)n); \ + JniDecl(jint,JniNameSuffix)(JniArgsEnvClass, jlong jpStmt, jint n){ \ + return (jint)CName(S3JniLongPtr_sqlite3_stmt(jpStmt), (int)n); \ } /** Create a trivial JNI wrapper for (boolish-int CName(sqlite3_stmt*)). */ #define WRAP_BOOL_STMT(JniNameSuffix,CName) \ - JniDecl(jboolean,JniNameSuffix)(JniArgsEnvClass, jobject pStmt){ \ - return CName(PtrGet_sqlite3_stmt(pStmt)) ? JNI_TRUE : JNI_FALSE; \ + JniDecl(jboolean,JniNameSuffix)(JniArgsEnvClass, jlong jpStmt){ \ + return CName(S3JniLongPtr_sqlite3_stmt(jpStmt)) ? JNI_TRUE : JNI_FALSE; \ } /** Create a trivial JNI wrapper for (jstring CName(sqlite3_stmt*,int)). */ -#define WRAP_STR_STMT_INT(JniNameSuffix,CName) \ - JniDecl(jstring,JniNameSuffix)(JniArgsEnvClass, jobject pStmt, jint ndx){ \ +#define WRAP_STR_STMT_INT(JniNameSuffix,CName) \ + JniDecl(jstring,JniNameSuffix)(JniArgsEnvClass, jlong jpStmt, jint ndx){ \ return s3jni_utf8_to_jstring( \ - CName(PtrGet_sqlite3_stmt(pStmt), (int)ndx), \ - -1); \ - } -/** Create a trivial JNI wrapper for (int CName(sqlite3*)). */ -#define WRAP_INT_DB(JniNameSuffix,CName) \ - JniDecl(jint,JniNameSuffix)(JniArgsEnvClass, jobject pDb){ \ - return (jint)CName(PtrGet_sqlite3(pDb)); \ + CName(S3JniLongPtr_sqlite3_stmt(jpStmt), (int)ndx), \ + -1); \ } /** Create a trivial JNI wrapper for (boolean CName(sqlite3*)). */ -#define WRAP_BOOL_DB(JniNameSuffix,CName) \ - JniDecl(jboolean,JniNameSuffix)(JniArgsEnvClass, jobject pDb){ \ - return CName(PtrGet_sqlite3(pDb)) ? JNI_TRUE : JNI_FALSE; \ +#define WRAP_BOOL_DB(JniNameSuffix,CName) \ + JniDecl(jboolean,JniNameSuffix)(JniArgsEnvClass, jlong jpDb){ \ + return CName(S3JniLongPtr_sqlite3(jpDb)) ? JNI_TRUE : JNI_FALSE; \ + } +/** Create a trivial JNI wrapper for (int CName(sqlite3*)). */ +#define WRAP_INT_DB(JniNameSuffix,CName) \ + JniDecl(jint,JniNameSuffix)(JniArgsEnvClass, jlong jpDb){ \ + return (jint)CName(S3JniLongPtr_sqlite3(jpDb)); \ } /** Create a trivial JNI wrapper for (int64 CName(sqlite3*)). */ -#define WRAP_INT64_DB(JniNameSuffix,CName) \ - JniDecl(jlong,JniNameSuffix)(JniArgsEnvClass, jobject pDb){ \ - return (jlong)CName(PtrGet_sqlite3(pDb)); \ +#define WRAP_INT64_DB(JniNameSuffix,CName) \ + JniDecl(jlong,JniNameSuffix)(JniArgsEnvClass, jlong jpDb){ \ + return (jlong)CName(S3JniLongPtr_sqlite3(jpDb)); \ } /** Create a trivial JNI wrapper for (int CName(sqlite3_value*)). */ #define WRAP_INT_SVALUE(JniNameSuffix,CName) \ - JniDecl(jint,JniNameSuffix)(JniArgsEnvClass, jobject jpSValue){ \ - return (jint)CName(PtrGet_sqlite3_value(jpSValue)); \ + JniDecl(jint,JniNameSuffix)(JniArgsEnvClass, jlong jpSValue){ \ + return (jint)CName(S3JniLongPtr_sqlite3_value(jpSValue)); \ } -WRAP_INT_STMT(1bind_1parameter_1count, sqlite3_bind_parameter_count) WRAP_INT_DB(1changes, sqlite3_changes) WRAP_INT64_DB(1changes64, sqlite3_changes64) WRAP_INT_STMT(1clear_1bindings, sqlite3_clear_bindings) @@ -2236,19 +2236,21 @@ S3JniApi(sqlite3_auto_extension(),jint,1auto_1extension)( } S3JniApi(sqlite3_backup_finish(),jint,1backup_1finish)( - JniArgsEnvClass, jobject jBack + JniArgsEnvClass, jlong jpBack ){ - sqlite3_backup * const pB = PtrGet_sqlite3_backup(jBack); - NativePointerHolder_set(S3JniNph(sqlite3_backup), jBack, 0); - return sqlite3_backup_finish(pB); + int rc = 0; + if( jpBack!=0 ){ + rc = sqlite3_backup_finish( S3JniLongPtr_sqlite3_backup(jpBack) ); + } + return rc; } S3JniApi(sqlite3_backup_init(),jobject,1backup_1init)( - JniArgsEnvClass, jobject jDbDest, jstring jTDest, - jobject jDbSrc, jstring jTSrc + JniArgsEnvClass, jlong jpDbDest, jstring jTDest, + jlong jpDbSrc, jstring jTSrc ){ - sqlite3 * const pDest = PtrGet_sqlite3(jDbDest); - sqlite3 * const pSrc = PtrGet_sqlite3(jDbSrc); + sqlite3 * const pDest = S3JniLongPtr_sqlite3(jpDbDest); + sqlite3 * const pSrc = S3JniLongPtr_sqlite3(jpDbSrc); char * const zDest = s3jni_jstring_to_utf8(jTDest, 0); char * const zSrc = s3jni_jstring_to_utf8(jTSrc, 0); jobject rv = 0; @@ -2269,66 +2271,67 @@ S3JniApi(sqlite3_backup_init(),jobject,1backup_1init)( } S3JniApi(sqlite3_backup_pagecount(),jint,1backup_1pagecount)( - JniArgsEnvClass, jobject jBack + JniArgsEnvClass, jlong jpBack ){ - return sqlite3_backup_pagecount(PtrGet_sqlite3_backup(jBack)); + return sqlite3_backup_pagecount(S3JniLongPtr_sqlite3_backup(jpBack)); } S3JniApi(sqlite3_backup_remaining(),jint,1backup_1remaining)( - JniArgsEnvClass, jobject jBack + JniArgsEnvClass, jlong jpBack ){ - return sqlite3_backup_remaining(PtrGet_sqlite3_backup(jBack)); + return sqlite3_backup_remaining(S3JniLongPtr_sqlite3_backup(jpBack)); } S3JniApi(sqlite3_backup_step(),jint,1backup_1step)( - JniArgsEnvClass, jobject jBack, jint nPage + JniArgsEnvClass, jlong jpBack, jint nPage ){ - return sqlite3_backup_step(PtrGet_sqlite3_backup(jBack), (int)nPage); + return sqlite3_backup_step(S3JniLongPtr_sqlite3_backup(jpBack), (int)nPage); } S3JniApi(sqlite3_bind_blob(),jint,1bind_1blob)( - JniArgsEnvClass, jobject jpStmt, jint ndx, jbyteArray baData, jint nMax + JniArgsEnvClass, jlong jpStmt, jint ndx, jbyteArray baData, jint nMax ){ jbyte * const pBuf = baData ? s3jni_jbyteArray_bytes(baData) : 0; int rc; if( pBuf ){ - rc = sqlite3_bind_blob(PtrGet_sqlite3_stmt(jpStmt), (int)ndx, + rc = sqlite3_bind_blob(S3JniLongPtr_sqlite3_stmt(jpStmt), (int)ndx, pBuf, (int)nMax, SQLITE_TRANSIENT); s3jni_jbyteArray_release(baData, pBuf); }else{ rc = baData ? SQLITE_NOMEM - : sqlite3_bind_null( PtrGet_sqlite3_stmt(jpStmt), ndx ); + : sqlite3_bind_null( S3JniLongPtr_sqlite3_stmt(jpStmt), ndx ); } return (jint)rc; } S3JniApi(sqlite3_bind_double(),jint,1bind_1double)( - JniArgsEnvClass, jobject jpStmt, jint ndx, jdouble val + JniArgsEnvClass, jlong jpStmt, jint ndx, jdouble val ){ - return (jint)sqlite3_bind_double(PtrGet_sqlite3_stmt(jpStmt), (int)ndx, (double)val); + return (jint)sqlite3_bind_double(S3JniLongPtr_sqlite3_stmt(jpStmt), + (int)ndx, (double)val); } S3JniApi(sqlite3_bind_int(),jint,1bind_1int)( - JniArgsEnvClass, jobject jpStmt, jint ndx, jint val + JniArgsEnvClass, jlong jpStmt, jint ndx, jint val ){ - return (jint)sqlite3_bind_int(PtrGet_sqlite3_stmt(jpStmt), (int)ndx, (int)val); + return (jint)sqlite3_bind_int(S3JniLongPtr_sqlite3_stmt(jpStmt), (int)ndx, (int)val); } S3JniApi(sqlite3_bind_int64(),jint,1bind_1int64)( - JniArgsEnvClass, jobject jpStmt, jint ndx, jlong val + JniArgsEnvClass, jlong jpStmt, jint ndx, jlong val ){ - return (jint)sqlite3_bind_int64(PtrGet_sqlite3_stmt(jpStmt), (int)ndx, (sqlite3_int64)val); + return (jint)sqlite3_bind_int64(S3JniLongPtr_sqlite3_stmt(jpStmt), (int)ndx, (sqlite3_int64)val); } /* ** Bind a new global ref to Object `val` using sqlite3_bind_pointer(). */ S3JniApi(sqlite3_bind_java_object(),jint,1bind_1java_1object)( - JniArgsEnvClass, jobject jpStmt, jint ndx, jobject val + JniArgsEnvClass, jlong jpStmt, jint ndx, jobject val ){ - sqlite3_stmt * const pStmt = PtrGet_sqlite3_stmt(jpStmt); - int rc = 0; + sqlite3_stmt * const pStmt = S3JniLongPtr_sqlite3_stmt(jpStmt); + int rc = SQLITE_MISUSE; if(pStmt){ jobject const rv = val ? S3JniRefGlobal(val) : 0; @@ -2337,26 +2340,32 @@ S3JniApi(sqlite3_bind_java_object(),jint,1bind_1java_1object)( S3Jni_jobject_finalizer); }else if(val){ rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_bind_null(pStmt, ndx); } - }else{ - rc = SQLITE_MISUSE; } return rc; } S3JniApi(sqlite3_bind_null(),jint,1bind_1null)( - JniArgsEnvClass, jobject jpStmt, jint ndx + JniArgsEnvClass, jlong jpStmt, jint ndx ){ - return (jint)sqlite3_bind_null(PtrGet_sqlite3_stmt(jpStmt), (int)ndx); + return (jint)sqlite3_bind_null(S3JniLongPtr_sqlite3_stmt(jpStmt), (int)ndx); +} + +S3JniApi(sqlite3_bind_parameter_count(),jint,1bind_1parameter_1count)( + JniArgsEnvClass, jlong jpStmt +){ + return (jint)sqlite3_bind_parameter_count(S3JniLongPtr_sqlite3_stmt(jpStmt)); } S3JniApi(sqlite3_bind_parameter_index(),jint,1bind_1parameter_1index)( - JniArgsEnvClass, jobject jpStmt, jbyteArray jName + JniArgsEnvClass, jlong jpStmt, jbyteArray jName ){ int rc = 0; jbyte * const pBuf = s3jni_jbyteArray_bytes(jName); if( pBuf ){ - rc = sqlite3_bind_parameter_index(PtrGet_sqlite3_stmt(jpStmt), + rc = sqlite3_bind_parameter_index(S3JniLongPtr_sqlite3_stmt(jpStmt), (const char *)pBuf); s3jni_jbyteArray_release(jName, pBuf); } @@ -2364,23 +2373,18 @@ S3JniApi(sqlite3_bind_parameter_index(),jint,1bind_1parameter_1index)( } S3JniApi(sqlite3_bind_parameter_name(),jstring,1bind_1parameter_1name)( - JniArgsEnvClass, jobject jpStmt, jint ndx + JniArgsEnvClass, jlong jpStmt, jint ndx ){ - jstring rv = 0; const char *z = - sqlite3_bind_parameter_name(PtrGet_sqlite3_stmt(jpStmt), (int)ndx); - - if( z ){ - rv = s3jni_utf8_to_jstring(z, -1); - } - return rv; + sqlite3_bind_parameter_name(S3JniLongPtr_sqlite3_stmt(jpStmt), (int)ndx); + return z ? s3jni_utf8_to_jstring(z, -1) : 0; } S3JniApi(sqlite3_bind_text(),jint,1bind_1text)( - JniArgsEnvClass, jobject jpStmt, jint ndx, jbyteArray baData, jint nMax + JniArgsEnvClass, jlong jpStmt, jint ndx, jbyteArray baData, jint nMax ){ jbyte * const pBuf = baData ? s3jni_jbyteArray_bytes(baData) : 0; - int const rc = sqlite3_bind_text(PtrGet_sqlite3_stmt(jpStmt), (int)ndx, + int const rc = sqlite3_bind_text(S3JniLongPtr_sqlite3_stmt(jpStmt), (int)ndx, (const char *)pBuf, (int)nMax, SQLITE_TRANSIENT); s3jni_jbyteArray_release(baData, pBuf); @@ -2388,49 +2392,47 @@ S3JniApi(sqlite3_bind_text(),jint,1bind_1text)( } S3JniApi(sqlite3_bind_text16(),jint,1bind_1text16)( - JniArgsEnvClass, jobject jpStmt, jint ndx, jbyteArray baData, jint nMax + JniArgsEnvClass, jlong jpStmt, jint ndx, jbyteArray baData, jint nMax ){ jbyte * const pBuf = baData ? s3jni_jbyteArray_bytes(baData) : 0; - int const rc = sqlite3_bind_text16(PtrGet_sqlite3_stmt(jpStmt), (int)ndx, + int const rc = sqlite3_bind_text16(S3JniLongPtr_sqlite3_stmt(jpStmt), (int)ndx, pBuf, (int)nMax, SQLITE_TRANSIENT); s3jni_jbyteArray_release(baData, pBuf); return (jint)rc; } S3JniApi(sqlite3_bind_zeroblob(),jint,1bind_1zeroblob)( - JniArgsEnvClass, jobject jpStmt, jint ndx, jint n + JniArgsEnvClass, jlong jpStmt, jint ndx, jint n ){ - return (jint)sqlite3_bind_zeroblob(PtrGet_sqlite3_stmt(jpStmt), (int)ndx, (int)n); + return (jint)sqlite3_bind_zeroblob(S3JniLongPtr_sqlite3_stmt(jpStmt), + (int)ndx, (int)n); } -S3JniApi(sqlite3_bind_zeroblob(),jint,1bind_1zeroblob64)( - JniArgsEnvClass, jobject jpStmt, jint ndx, jlong n +S3JniApi(sqlite3_bind_zeroblob64(),jint,1bind_1zeroblob64)( + JniArgsEnvClass, jlong jpStmt, jint ndx, jlong n ){ - return (jint)sqlite3_bind_zeroblob(PtrGet_sqlite3_stmt(jpStmt), (int)ndx, (sqlite3_uint64)n); + return (jint)sqlite3_bind_zeroblob64(S3JniLongPtr_sqlite3_stmt(jpStmt), + (int)ndx, (sqlite3_uint64)n); } S3JniApi(sqlite3_blob_bytes(),jint,1blob_1bytes)( - JniArgsEnvClass, jobject jBlob + JniArgsEnvClass, jlong jpBlob ){ - return sqlite3_blob_bytes(PtrGet_sqlite3_blob(jBlob)); + return sqlite3_blob_bytes(S3JniLongPtr_sqlite3_blob(jpBlob)); } S3JniApi(sqlite3_blob_close(),jint,1blob_1close)( - JniArgsEnvClass, jobject jBlob + JniArgsEnvClass, jlong jpBlob ){ - sqlite3_blob * const b = PtrGet_sqlite3_blob(jBlob); - jint const rc = b ? (jint)sqlite3_blob_close(b) : SQLITE_MISUSE; - if( b ){ - NativePointerHolder_set(S3JniNph(sqlite3_blob), jBlob, 0); - } - return rc; + sqlite3_blob * const b = S3JniLongPtr_sqlite3_blob(jpBlob); + return b ? (jint)sqlite3_blob_close(b) : SQLITE_MISUSE; } S3JniApi(sqlite3_blob_open(),jint,1blob_1open)( - JniArgsEnvClass, jobject jDb, jstring jDbName, jstring jTbl, jstring jCol, + JniArgsEnvClass, jlong jpDb, jstring jDbName, jstring jTbl, jstring jCol, jlong jRowId, jint flags, jobject jOut ){ - sqlite3 * const db = PtrGet_sqlite3(jDb); + sqlite3 * const db = S3JniLongPtr_sqlite3(jpDb); sqlite3_blob * pBlob = 0; char * zDbName = 0, * zTableName = 0, * zColumnName = 0; int rc; @@ -2458,13 +2460,13 @@ S3JniApi(sqlite3_blob_open(),jint,1blob_1open)( } S3JniApi(sqlite3_blob_read(),jint,1blob_1read)( - JniArgsEnvClass, jobject jBlob, jbyteArray jTgt, jint iOffset + JniArgsEnvClass, jlong jpBlob, jbyteArray jTgt, jint iOffset ){ jbyte * const pBa = s3jni_jbyteArray_bytes(jTgt); int rc = jTgt ? (pBa ? SQLITE_MISUSE : SQLITE_NOMEM) : SQLITE_MISUSE; if( pBa ){ jsize const nTgt = (*env)->GetArrayLength(env, jTgt); - rc = sqlite3_blob_read(PtrGet_sqlite3_blob(jBlob), pBa, + rc = sqlite3_blob_read(S3JniLongPtr_sqlite3_blob(jpBlob), pBa, (int)nTgt, (int)iOffset); if( 0==rc ){ s3jni_jbyteArray_commit(jTgt, pBa); @@ -2476,16 +2478,16 @@ S3JniApi(sqlite3_blob_read(),jint,1blob_1read)( } S3JniApi(sqlite3_blob_reopen(),jint,1blob_1reopen)( - JniArgsEnvClass, jobject jBlob, jlong iNewRowId + JniArgsEnvClass, jlong jpBlob, jlong iNewRowId ){ - return (jint)sqlite3_blob_reopen(PtrGet_sqlite3_blob(jBlob), + return (jint)sqlite3_blob_reopen(S3JniLongPtr_sqlite3_blob(jpBlob), (sqlite3_int64)iNewRowId); } S3JniApi(sqlite3_blob_write(),jint,1blob_1write)( - JniArgsEnvClass, jobject jBlob, jbyteArray jBa, jint iOffset + JniArgsEnvClass, jlong jpBlob, jbyteArray jBa, jint iOffset ){ - sqlite3_blob * const b = PtrGet_sqlite3_blob(jBlob); + sqlite3_blob * const b = S3JniLongPtr_sqlite3_blob(jpBlob); jbyte * const pBuf = b ? s3jni_jbyteArray_bytes(jBa) : 0; const jsize nBa = pBuf ? (*env)->GetArrayLength(env, jBa) : 0; int rc = SQLITE_MISUSE; @@ -2503,7 +2505,7 @@ static int s3jni_busy_handler(void* pState, int n){ S3JniDeclLocal_env; S3JniHook hook; - S3JniHook_localdup(&ps->hooks.busyHandler, &hook ); + S3JniHook_localdup(&ps->hooks.busyHandler, &hook); if( hook.jObj ){ rc = (*env)->CallIntMethod(env, hook.jObj, hook.midCallback, (jint)n); @@ -2518,9 +2520,9 @@ static int s3jni_busy_handler(void* pState, int n){ } S3JniApi(sqlite3_busy_handler(),jint,1busy_1handler)( - JniArgsEnvClass, jobject jDb, jobject jBusy + JniArgsEnvClass, jlong jpDb, jobject jBusy ){ - S3JniDb * const ps = S3JniDb_from_java(jDb); + S3JniDb * const ps = S3JniDb_from_jlong(jpDb); S3JniHook * const pHook = ps ? &ps->hooks.busyHandler : 0; S3JniHook hook = S3JniHook_empty; int rc = 0; @@ -2563,9 +2565,9 @@ S3JniApi(sqlite3_busy_handler(),jint,1busy_1handler)( } S3JniApi(sqlite3_busy_timeout(),jint,1busy_1timeout)( - JniArgsEnvClass, jobject jDb, jint ms + JniArgsEnvClass, jlong jpDb, jint ms ){ - S3JniDb * const ps = S3JniDb_from_java(jDb); + S3JniDb * const ps = S3JniDb_from_jlong(jpDb); int rc = SQLITE_MISUSE; if( ps ){ S3JniDb_mutex_enter; @@ -2602,32 +2604,25 @@ S3JniApi(sqlite3_cancel_auto_extension(),jboolean,1cancel_1auto_1extension)( } /* Wrapper for sqlite3_close(_v2)(). */ -static jint s3jni_close_db(JNIEnv * const env, jobject jDb, int version){ +static jint s3jni_close_db(JNIEnv * const env, jlong jpDb, int version){ int rc = 0; - S3JniDb * const ps = S3JniDb_from_java(jDb); + S3JniDb * const ps = S3JniDb_from_jlong(jpDb); assert(version == 1 || version == 2); if( ps ){ rc = 1==version ? (jint)sqlite3_close(ps->pDb) : (jint)sqlite3_close_v2(ps->pDb); - if( 0==rc ){ - NativePointerHolder_set(S3JniNph(sqlite3), jDb, 0); - } } return (jint)rc; } -S3JniApi(sqlite3_close_v2(),jint,1close_1v2)( - JniArgsEnvClass, jobject pDb -){ - return s3jni_close_db(env, pDb, 2); +S3JniApi(sqlite3_close(),jint,1close)(JniArgsEnvClass, jlong pDb){ + return s3jni_close_db(env, pDb, 1); } -S3JniApi(sqlite3_close(),jint,1close)( - JniArgsEnvClass, jobject pDb -){ - return s3jni_close_db(env, pDb, 1); +S3JniApi(sqlite3_close_v2(),jint,1close_1v2)(JniArgsEnvClass, jlong pDb){ + return s3jni_close_db(env, pDb, 2); } /* @@ -2673,14 +2668,14 @@ static void s3jni_collation_needed_impl16(void *pState, sqlite3 *pDb, } S3JniApi(sqlite3_collation_needed(),jint,1collation_1needed)( - JniArgsEnvClass, jobject jDb, jobject jHook + JniArgsEnvClass, jlong jpDb, jobject jHook ){ S3JniDb * ps; S3JniCollationNeeded * pHook; int rc = 0; S3JniDb_mutex_enter; - ps = S3JniDb_from_java(jDb); + ps = S3JniDb_from_jlong(jpDb); if( !ps ){ S3JniDb_mutex_leave; return SQLITE_MISUSE; @@ -2823,13 +2818,13 @@ static void s3jni_rollback_hook_impl(void *pP){ ** sqlite3_rollback_hook(). */ static jobject s3jni_commit_rollback_hook(int isCommit, JNIEnv * const env, - jobject jDb, jobject jHook){ + jlong jpDb, jobject jHook){ S3JniDb * ps; jobject pOld = 0; /* previous hoook */ S3JniHook * pHook; /* ps->hooks.commit|rollback */ S3JniDb_mutex_enter; - ps = S3JniDb_from_java(jDb); + ps = S3JniDb_from_jlong(jpDb); if( !ps ){ s3jni_db_error(ps->pDb, SQLITE_NOMEM, 0); S3JniDb_mutex_leave; @@ -2877,9 +2872,9 @@ static jobject s3jni_commit_rollback_hook(int isCommit, JNIEnv * const env, } S3JniApi(sqlite3_commit_hook(),jobject,1commit_1hook)( - JniArgsEnvClass,jobject jDb, jobject jHook + JniArgsEnvClass, jlong jpDb, jobject jHook ){ - return s3jni_commit_rollback_hook(1, env, jDb, jHook); + return s3jni_commit_rollback_hook(1, env, jpDb, jHook); } S3JniApi(sqlite3_compileoption_get(),jstring,1compileoption_1get)( @@ -2912,7 +2907,8 @@ S3JniApi(sqlite3_compileoption_used(),jboolean,1compileoption_1used)( JniArgsEnvClass, jstring name ){ const char *zUtf8 = s3jni_jstring_to_mutf8(name) - /* We know these to be ASCII, so MUTF-8 is fine. */; + /* We know these to be ASCII, so MUTF-8 is fine (and + hypothetically faster to convert). */; const jboolean rc = 0==sqlite3_compileoption_used(zUtf8) ? JNI_FALSE : JNI_TRUE; s3jni_mutf8_release(name, zUtf8); @@ -3125,7 +3121,7 @@ S3JniApi(sqlite3_create_collation() sqlite3_create_collation_v2(), S3JniDb_mutex_enter; ps = S3JniDb_from_java(jDb); - if( !ps ){ + if( !ps || !name ){ rc = SQLITE_MISUSE; }else{ jclass const klazz = (*env)->GetObjectClass(env, oCollation); @@ -3171,7 +3167,9 @@ S3JniApi(sqlite3_create_function() sqlite3_create_function_v2() sqlite3 * const pDb = PtrGet_sqlite3(jDb); char * zFuncName = 0; - if( !encodingTypeIsValid(eTextRep) ){ + if( !pDb || !jFuncName ){ + return SQLITE_MISUSE; + }else if( !encodingTypeIsValid(eTextRep) ){ return s3jni_db_error(pDb, SQLITE_FORMAT, "Invalid function encoding option."); } @@ -3408,15 +3406,11 @@ S3JniApi(sqlite3_extended_result_codes(),jboolean,1extended_1result_1codes)( } S3JniApi(sqlite3_finalize(),jint,1finalize)( - JniArgsEnvClass, jobject jpStmt + JniArgsEnvClass, jlong jpStmt ){ - int rc = 0; - sqlite3_stmt * const pStmt = PtrGet_sqlite3_stmt(jpStmt); - if( pStmt ){ - rc = sqlite3_finalize(pStmt); - NativePointerHolder_set(S3JniNph(sqlite3_stmt), jpStmt, 0); - } - return rc; + return jpStmt + ? sqlite3_finalize(S3JniLongPtr_sqlite3_stmt(jpStmt)) + : 0; } S3JniApi(sqlite3_get_auxdata(),jobject,1get_1auxdata)( @@ -3637,7 +3631,7 @@ S3JniApi(sqlite3_open_v2(),jint,1open_1v2)( /* Proxy for the sqlite3_prepare[_v2/3]() family. */ jint sqlite3_jni_prepare_v123( int prepVersion, JNIEnv * const env, jclass self, - jobject jDb, jbyteArray baSql, + jlong jpDb, jbyteArray baSql, jint nMax, jint prepFlags, jobject jOutStmt, jobject outTail){ sqlite3_stmt * pStmt = 0; @@ -3656,18 +3650,18 @@ jint sqlite3_jni_prepare_v123( int prepVersion, JNIEnv * const env, jclass self, goto end; } switch( prepVersion ){ - case 1: rc = sqlite3_prepare(PtrGet_sqlite3(jDb), (const char *)pBuf, + case 1: rc = sqlite3_prepare(S3JniLongPtr_sqlite3(jpDb), (const char *)pBuf, (int)nMax, &pStmt, &zTail); break; - case 2: rc = sqlite3_prepare_v2(PtrGet_sqlite3(jDb), (const char *)pBuf, + case 2: rc = sqlite3_prepare_v2(S3JniLongPtr_sqlite3(jpDb), (const char *)pBuf, (int)nMax, &pStmt, &zTail); break; - case 3: rc = sqlite3_prepare_v3(PtrGet_sqlite3(jDb), (const char *)pBuf, + case 3: rc = sqlite3_prepare_v3(S3JniLongPtr_sqlite3(jpDb), (const char *)pBuf, (int)nMax, (unsigned int)prepFlags, &pStmt, &zTail); break; default: - assert(0 && "Invalid prepare() version"); + assert(!"Invalid prepare() version"); } end: s3jni_jbyteArray_release(baSql,pBuf); @@ -3697,24 +3691,24 @@ end: return (jint)rc; } S3JniApi(sqlite3_prepare(),jint,1prepare)( - JNIEnv * const env, jclass self, jobject jDb, jbyteArray baSql, + JNIEnv * const env, jclass self, jlong jpDb, jbyteArray baSql, jint nMax, jobject jOutStmt, jobject outTail ){ - return sqlite3_jni_prepare_v123(1, env, self, jDb, baSql, nMax, 0, + return sqlite3_jni_prepare_v123(1, env, self, jpDb, baSql, nMax, 0, jOutStmt, outTail); } S3JniApi(sqlite3_prepare_v2(),jint,1prepare_1v2)( - JNIEnv * const env, jclass self, jobject jDb, jbyteArray baSql, + JNIEnv * const env, jclass self, jlong jpDb, jbyteArray baSql, jint nMax, jobject jOutStmt, jobject outTail ){ - return sqlite3_jni_prepare_v123(2, env, self, jDb, baSql, nMax, 0, + return sqlite3_jni_prepare_v123(2, env, self, jpDb, baSql, nMax, 0, jOutStmt, outTail); } S3JniApi(sqlite3_prepare_v3(),jint,1prepare_1v3)( - JNIEnv * const env, jclass self, jobject jDb, jbyteArray baSql, + JNIEnv * const env, jclass self, jlong jpDb, jbyteArray baSql, jint nMax, jint prepFlags, jobject jOutStmt, jobject outTail ){ - return sqlite3_jni_prepare_v123(3, env, self, jDb, baSql, nMax, + return sqlite3_jni_prepare_v123(3, env, self, jpDb, baSql, nMax, prepFlags, jOutStmt, outTail); } @@ -3803,8 +3797,8 @@ S3JniApi(sqlite3_preupdate_depth(),int,1preupdate_1depth)( ** JNI wrapper for both sqlite3_update_hook() and ** sqlite3_preupdate_hook() (if isPre is true). */ -static jobject s3jni_updatepre_hook(JNIEnv * env, int isPre, jobject jDb, jobject jHook){ - S3JniDb * const ps = S3JniDb_from_java(jDb); +static jobject s3jni_updatepre_hook(JNIEnv * env, int isPre, jlong jpDb, jobject jHook){ + S3JniDb * const ps = S3JniDb_from_jlong(jpDb); jclass klazz; jobject pOld = 0; jmethodID xCallback; @@ -3877,20 +3871,20 @@ end: S3JniApi(sqlite3_preupdate_hook(),jobject,1preupdate_1hook)( - JniArgsEnvClass, jobject jDb, jobject jHook + JniArgsEnvClass, jlong jpDb, jobject jHook ){ #ifdef SQLITE_ENABLE_PREUPDATE_HOOK - return s3jni_updatepre_hook(env, 1, jDb, jHook); + return s3jni_updatepre_hook(env, 1, jpDb, jHook); #else return NULL; #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ } /* Impl for sqlite3_preupdate_{new,old}(). */ -static int s3jni_preupdate_newold(JNIEnv * const env, int isNew, jobject jDb, +static int s3jni_preupdate_newold(JNIEnv * const env, int isNew, jlong jpDb, jint iCol, jobject jOut){ #ifdef SQLITE_ENABLE_PREUPDATE_HOOK - sqlite3 * const pDb = PtrGet_sqlite3(jDb); + sqlite3 * const pDb = S3JniLongPtr_sqlite3(jpDb); int rc = SQLITE_MISUSE; if( pDb ){ sqlite3_value * pOut = 0; @@ -3914,15 +3908,15 @@ static int s3jni_preupdate_newold(JNIEnv * const env, int isNew, jobject jDb, } S3JniApi(sqlite3_preupdate_new(),jint,1preupdate_1new)( - JniArgsEnvClass, jobject jDb, jint iCol, jobject jOut + JniArgsEnvClass, jlong jpDb, jint iCol, jobject jOut ){ - return s3jni_preupdate_newold(env, 1, jDb, iCol, jOut); + return s3jni_preupdate_newold(env, 1, jpDb, iCol, jOut); } S3JniApi(sqlite3_preupdate_old(),jint,1preupdate_1old)( - JniArgsEnvClass, jobject jDb, jint iCol, jobject jOut + JniArgsEnvClass, jlong jpDb, jint iCol, jobject jOut ){ - return s3jni_preupdate_newold(env, 0, jDb, iCol, jOut); + return s3jni_preupdate_newold(env, 0, jpDb, iCol, jOut); } @@ -4222,9 +4216,9 @@ S3JniApi(sqlite3_result_zeroblob64(),jint,1result_1zeroblob64)( } S3JniApi(sqlite3_rollback_hook(),jobject,1rollback_1hook)( - JniArgsEnvClass, jobject jDb, jobject jHook + JniArgsEnvClass, jlong jpDb, jobject jHook ){ - return s3jni_commit_rollback_hook(0, env, jDb, jHook); + return s3jni_commit_rollback_hook(0, env, jpDb, jHook); } /* Callback for sqlite3_set_authorizer(). */ @@ -4630,16 +4624,16 @@ S3JniApi(sqlite3_txn_state(),jint,1txn_1state)( } S3JniApi(sqlite3_update_hook(),jobject,1update_1hook)( - JniArgsEnvClass, jobject jDb, jobject jHook + JniArgsEnvClass, jlong jpDb, jobject jHook ){ - return s3jni_updatepre_hook(env, 0, jDb, jHook); + return s3jni_updatepre_hook(env, 0, jpDb, jHook); } S3JniApi(sqlite3_value_blob(),jbyteArray,1value_1blob)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - sqlite3_value * const sv = PtrGet_sqlite3_value(jpSVal); + sqlite3_value * const sv = S3JniLongPtr_sqlite3_value(jpSVal); int const nLen = sqlite3_value_bytes(sv); const jbyte * pBytes = sqlite3_value_blob(sv); @@ -4651,48 +4645,48 @@ S3JniApi(sqlite3_value_blob(),jbyteArray,1value_1blob)( S3JniApi(sqlite3_value_double(),jdouble,1value_1double)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - return (jdouble) sqlite3_value_double(PtrGet_sqlite3_value(jpSVal)); + return (jdouble) sqlite3_value_double(S3JniLongPtr_sqlite3_value(jpSVal)); } S3JniApi(sqlite3_value_dup(),jobject,1value_1dup)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - sqlite3_value * const sv = sqlite3_value_dup(PtrGet_sqlite3_value(jpSVal)); + sqlite3_value * const sv = sqlite3_value_dup(S3JniLongPtr_sqlite3_value(jpSVal)); return sv ? new_java_sqlite3_value(env, sv) : 0; } S3JniApi(sqlite3_value_free(),void,1value_1free)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - sqlite3_value_free(PtrGet_sqlite3_value(jpSVal)); + sqlite3_value_free(S3JniLongPtr_sqlite3_value(jpSVal)); } S3JniApi(sqlite3_value_int(),jint,1value_1int)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - return (jint) sqlite3_value_int(PtrGet_sqlite3_value(jpSVal)); + return (jint) sqlite3_value_int(S3JniLongPtr_sqlite3_value(jpSVal)); } S3JniApi(sqlite3_value_int64(),jlong,1value_1int64)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - return (jlong) sqlite3_value_int64(PtrGet_sqlite3_value(jpSVal)); + return (jlong) sqlite3_value_int64(S3JniLongPtr_sqlite3_value(jpSVal)); } S3JniApi(sqlite3_value_java_object(),jobject,1value_1java_1object)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - return sqlite3_value_pointer(PtrGet_sqlite3_value(jpSVal), + return sqlite3_value_pointer(S3JniLongPtr_sqlite3_value(jpSVal), ResultJavaValuePtrStr); } S3JniApi(sqlite3_value_text(),jbyteArray,1value_1text)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - sqlite3_value * const sv = PtrGet_sqlite3_value(jpSVal); + sqlite3_value * const sv = S3JniLongPtr_sqlite3_value(jpSVal); int const n = sqlite3_value_bytes(sv); const unsigned char * const p = sqlite3_value_text(sv); return p ? s3jni_new_jbyteArray(p, n) : 0; @@ -4701,9 +4695,9 @@ S3JniApi(sqlite3_value_text(),jbyteArray,1value_1text)( #if 0 // this impl might prove useful. S3JniApi(sqlite3_value_text(),jstring,1value_1text)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - sqlite3_value * const sv = PtrGet_sqlite3_value(jpSVal); + sqlite3_value * const sv = S3JniLongPtr_sqlite3_value(jpSVal); int const n = sqlite3_value_bytes(sv); const unsigned char * const p = sqlite3_value_text(sv); return p ? s3jni_utf8_to_jstring( (const char *)p, n) : 0; @@ -4711,9 +4705,9 @@ S3JniApi(sqlite3_value_text(),jstring,1value_1text)( #endif S3JniApi(sqlite3_value_text16(),jstring,1value_1text16)( - JniArgsEnvClass, jobject jpSVal + JniArgsEnvClass, jlong jpSVal ){ - sqlite3_value * const sv = PtrGet_sqlite3_value(jpSVal); + sqlite3_value * const sv = S3JniLongPtr_sqlite3_value(jpSVal); const int n = sqlite3_value_bytes16(sv); const void * const p = sqlite3_value_text16(sv); return s3jni_text16_to_jstring(env, p, n); @@ -5575,7 +5569,7 @@ static int SQLTester_strnotglob(const char *zGlob, const char *z){ } JNIEXPORT jint JNICALL -Java_org_sqlite_jni_tester_SQLTester_strglob( +Java_org_sqlite_jni_SQLTester_strglob( JniArgsEnvClass, jbyteArray baG, jbyteArray baT ){ int rc = 0; @@ -5602,7 +5596,7 @@ static int SQLTester_auto_extension(sqlite3 *pDb, const char **pzErr, } JNIEXPORT void JNICALL -Java_org_sqlite_jni_tester_SQLTester_installCustomExtensions(JniArgsEnvClass){ +Java_org_sqlite_jni_SQLTester_installCustomExtensions(JniArgsEnvClass){ sqlite3_auto_extension( (void(*)(void))SQLTester_auto_extension ); } diff --git a/ext/jni/src/c/sqlite3-jni.h b/ext/jni/src/c/sqlite3-jni.h index 717a93267..99903d302 100644 --- a/ext/jni/src/c/sqlite3-jni.h +++ b/ext/jni/src/c/sqlite3-jni.h @@ -814,210 +814,210 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1auto_1extension /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_backup_finish - * Signature: (Lorg/sqlite/jni/sqlite3_backup;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1backup_1finish - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_backup_init - * Signature: (Lorg/sqlite/jni/sqlite3;Ljava/lang/String;Lorg/sqlite/jni/sqlite3;Ljava/lang/String;)Lorg/sqlite/jni/sqlite3_backup; + * Signature: (JLjava/lang/String;JLjava/lang/String;)Lorg/sqlite/jni/sqlite3_backup; */ JNIEXPORT jobject JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1backup_1init - (JNIEnv *, jclass, jobject, jstring, jobject, jstring); + (JNIEnv *, jclass, jlong, jstring, jlong, jstring); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_backup_pagecount - * Signature: (Lorg/sqlite/jni/sqlite3_backup;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1backup_1pagecount - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_backup_remaining - * Signature: (Lorg/sqlite/jni/sqlite3_backup;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1backup_1remaining - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_backup_step - * Signature: (Lorg/sqlite/jni/sqlite3_backup;I)I + * Signature: (JI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1backup_1step - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_blob - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I[BI)I + * Signature: (JI[BI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1blob - (JNIEnv *, jclass, jobject, jint, jbyteArray, jint); + (JNIEnv *, jclass, jlong, jint, jbyteArray, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_double - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;ID)I + * Signature: (JID)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1double - (JNIEnv *, jclass, jobject, jint, jdouble); + (JNIEnv *, jclass, jlong, jint, jdouble); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_int - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;II)I + * Signature: (JII)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1int - (JNIEnv *, jclass, jobject, jint, jint); + (JNIEnv *, jclass, jlong, jint, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_int64 - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;IJ)I + * Signature: (JIJ)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1int64 - (JNIEnv *, jclass, jobject, jint, jlong); + (JNIEnv *, jclass, jlong, jint, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_java_object - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;ILjava/lang/Object;)I + * Signature: (JILjava/lang/Object;)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1java_1object - (JNIEnv *, jclass, jobject, jint, jobject); + (JNIEnv *, jclass, jlong, jint, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_null - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)I + * Signature: (JI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1null - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_parameter_count - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1parameter_1count - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_parameter_index - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;[B)I + * Signature: (J[B)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1parameter_1index - (JNIEnv *, jclass, jobject, jbyteArray); + (JNIEnv *, jclass, jlong, jbyteArray); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_parameter_name - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)Ljava/lang/String; + * Signature: (JI)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1parameter_1name - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_text - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I[BI)I + * Signature: (JI[BI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1text - (JNIEnv *, jclass, jobject, jint, jbyteArray, jint); + (JNIEnv *, jclass, jlong, jint, jbyteArray, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_text16 - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I[BI)I + * Signature: (JI[BI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1text16 - (JNIEnv *, jclass, jobject, jint, jbyteArray, jint); + (JNIEnv *, jclass, jlong, jint, jbyteArray, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_zeroblob - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;II)I + * Signature: (JII)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1zeroblob - (JNIEnv *, jclass, jobject, jint, jint); + (JNIEnv *, jclass, jlong, jint, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_bind_zeroblob64 - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;IJ)I + * Signature: (JIJ)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1bind_1zeroblob64 - (JNIEnv *, jclass, jobject, jint, jlong); + (JNIEnv *, jclass, jlong, jint, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_blob_bytes - * Signature: (Lorg/sqlite/jni/sqlite3_blob;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1bytes - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_blob_close - * Signature: (Lorg/sqlite/jni/sqlite3_blob;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1close - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_blob_open - * Signature: (Lorg/sqlite/jni/sqlite3;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;JILorg/sqlite/jni/OutputPointer/sqlite3_blob;)I + * Signature: (JLjava/lang/String;Ljava/lang/String;Ljava/lang/String;JILorg/sqlite/jni/OutputPointer/sqlite3_blob;)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1open - (JNIEnv *, jclass, jobject, jstring, jstring, jstring, jlong, jint, jobject); + (JNIEnv *, jclass, jlong, jstring, jstring, jstring, jlong, jint, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_blob_read - * Signature: (Lorg/sqlite/jni/sqlite3_blob;[BI)I + * Signature: (J[BI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1read - (JNIEnv *, jclass, jobject, jbyteArray, jint); + (JNIEnv *, jclass, jlong, jbyteArray, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_blob_reopen - * Signature: (Lorg/sqlite/jni/sqlite3_blob;J)I + * Signature: (JJ)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1reopen - (JNIEnv *, jclass, jobject, jlong); + (JNIEnv *, jclass, jlong, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_blob_write - * Signature: (Lorg/sqlite/jni/sqlite3_blob;[BI)I + * Signature: (J[BI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1blob_1write - (JNIEnv *, jclass, jobject, jbyteArray, jint); + (JNIEnv *, jclass, jlong, jbyteArray, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_busy_handler - * Signature: (Lorg/sqlite/jni/sqlite3;Lorg/sqlite/jni/BusyHandlerCallback;)I + * Signature: (JLorg/sqlite/jni/BusyHandlerCallback;)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1busy_1handler - (JNIEnv *, jclass, jobject, jobject); + (JNIEnv *, jclass, jlong, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_busy_timeout - * Signature: (Lorg/sqlite/jni/sqlite3;I)I + * Signature: (JI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1busy_1timeout - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1030,42 +1030,42 @@ JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1cancel_1auto_ /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_changes - * Signature: (Lorg/sqlite/jni/sqlite3;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1changes - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_changes64 - * Signature: (Lorg/sqlite/jni/sqlite3;)J + * Signature: (J)J */ JNIEXPORT jlong JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1changes64 - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_clear_bindings - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1clear_1bindings - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_close - * Signature: (Lorg/sqlite/jni/sqlite3;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1close - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_close_v2 - * Signature: (Lorg/sqlite/jni/sqlite3;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1close_1v2 - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1078,26 +1078,34 @@ JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1blo /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_column_bytes - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)I + * Signature: (JI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1bytes - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_column_bytes16 - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)I + * Signature: (JI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1bytes16 - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_column_count - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1count - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); + +/* + * Class: org_sqlite_jni_SQLite3Jni + * Method: sqlite3_column_decltype + * Signature: (JI)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1decltype + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1126,34 +1134,34 @@ JNIEXPORT jlong JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1int64 /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_column_name - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)Ljava/lang/String; + * Signature: (JI)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1name - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_column_database_name - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)Ljava/lang/String; + * Signature: (JI)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1database_1name - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_column_origin_name - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)Ljava/lang/String; + * Signature: (JI)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1origin_1name - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_column_table_name - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)Ljava/lang/String; + * Signature: (JI)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1table_1name - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1174,10 +1182,10 @@ JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1text16 /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_column_type - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)I + * Signature: (JI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1type - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1190,18 +1198,18 @@ JNIEXPORT jobject JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1column_1value /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_collation_needed - * Signature: (Lorg/sqlite/jni/sqlite3;Lorg/sqlite/jni/CollationNeededCallback;)I + * Signature: (JLorg/sqlite/jni/CollationNeededCallback;)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1collation_1needed - (JNIEnv *, jclass, jobject, jobject); + (JNIEnv *, jclass, jlong, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_commit_hook - * Signature: (Lorg/sqlite/jni/sqlite3;Lorg/sqlite/jni/CommitHookCallback;)Lorg/sqlite/jni/CommitHookCallback; + * Signature: (JLorg/sqlite/jni/CommitHookCallback;)Lorg/sqlite/jni/CommitHookCallback; */ JNIEXPORT jobject JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1commit_1hook - (JNIEnv *, jclass, jobject, jobject); + (JNIEnv *, jclass, jlong, jobject); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1278,10 +1286,10 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1create_1function /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_data_count - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1data_1count - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1349,6 +1357,14 @@ JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1errmsg16 /* * Class: org_sqlite_jni_SQLite3Jni + * Method: sqlite3_error_offset + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1error_1offset + (JNIEnv *, jclass, jlong); + +/* + * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_errstr * Signature: (I)Ljava/lang/String; */ @@ -1366,10 +1382,10 @@ JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1expanded_1sql /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_extended_errcode - * Signature: (Lorg/sqlite/jni/sqlite3;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1extended_1errcode - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1382,10 +1398,10 @@ JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1extended_1res /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_get_autocommit - * Signature: (Lorg/sqlite/jni/sqlite3;)Z + * Signature: (J)Z */ JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1get_1autocommit - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1397,19 +1413,11 @@ JNIEXPORT jobject JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1get_1auxdata /* * Class: org_sqlite_jni_SQLite3Jni - * Method: sqlite3_error_offset - * Signature: (Lorg/sqlite/jni/sqlite3;)I - */ -JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1error_1offset - (JNIEnv *, jclass, jobject); - -/* - * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_finalize - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1finalize - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1510,74 +1518,74 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1open_1v2 /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_prepare - * Signature: (Lorg/sqlite/jni/sqlite3;[BILorg/sqlite/jni/OutputPointer/sqlite3_stmt;Lorg/sqlite/jni/OutputPointer/Int32;)I + * Signature: (J[BILorg/sqlite/jni/OutputPointer/sqlite3_stmt;Lorg/sqlite/jni/OutputPointer/Int32;)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1prepare - (JNIEnv *, jclass, jobject, jbyteArray, jint, jobject, jobject); + (JNIEnv *, jclass, jlong, jbyteArray, jint, jobject, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_prepare_v2 - * Signature: (Lorg/sqlite/jni/sqlite3;[BILorg/sqlite/jni/OutputPointer/sqlite3_stmt;Lorg/sqlite/jni/OutputPointer/Int32;)I + * Signature: (J[BILorg/sqlite/jni/OutputPointer/sqlite3_stmt;Lorg/sqlite/jni/OutputPointer/Int32;)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1prepare_1v2 - (JNIEnv *, jclass, jobject, jbyteArray, jint, jobject, jobject); + (JNIEnv *, jclass, jlong, jbyteArray, jint, jobject, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_prepare_v3 - * Signature: (Lorg/sqlite/jni/sqlite3;[BIILorg/sqlite/jni/OutputPointer/sqlite3_stmt;Lorg/sqlite/jni/OutputPointer/Int32;)I + * Signature: (J[BIILorg/sqlite/jni/OutputPointer/sqlite3_stmt;Lorg/sqlite/jni/OutputPointer/Int32;)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1prepare_1v3 - (JNIEnv *, jclass, jobject, jbyteArray, jint, jint, jobject, jobject); + (JNIEnv *, jclass, jlong, jbyteArray, jint, jint, jobject, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_preupdate_blobwrite - * Signature: (Lorg/sqlite/jni/sqlite3;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1preupdate_1blobwrite - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_preupdate_count - * Signature: (Lorg/sqlite/jni/sqlite3;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1preupdate_1count - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_preupdate_depth - * Signature: (Lorg/sqlite/jni/sqlite3;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1preupdate_1depth - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_preupdate_hook - * Signature: (Lorg/sqlite/jni/sqlite3;Lorg/sqlite/jni/PreupdateHookCallback;)Lorg/sqlite/jni/PreupdateHookCallback; + * Signature: (JLorg/sqlite/jni/PreupdateHookCallback;)Lorg/sqlite/jni/PreupdateHookCallback; */ JNIEXPORT jobject JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1preupdate_1hook - (JNIEnv *, jclass, jobject, jobject); + (JNIEnv *, jclass, jlong, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_preupdate_new - * Signature: (Lorg/sqlite/jni/sqlite3;ILorg/sqlite/jni/OutputPointer/sqlite3_value;)I + * Signature: (JILorg/sqlite/jni/OutputPointer/sqlite3_value;)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1preupdate_1new - (JNIEnv *, jclass, jobject, jint, jobject); + (JNIEnv *, jclass, jlong, jint, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_preupdate_old - * Signature: (Lorg/sqlite/jni/sqlite3;ILorg/sqlite/jni/OutputPointer/sqlite3_value;)I + * Signature: (JILorg/sqlite/jni/OutputPointer/sqlite3_value;)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1preupdate_1old - (JNIEnv *, jclass, jobject, jint, jobject); + (JNIEnv *, jclass, jlong, jint, jobject); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1750,10 +1758,10 @@ JNIEXPORT void JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1result_1text64 /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_rollback_hook - * Signature: (Lorg/sqlite/jni/sqlite3;Lorg/sqlite/jni/RollbackHookCallback;)Lorg/sqlite/jni/RollbackHookCallback; + * Signature: (JLorg/sqlite/jni/RollbackHookCallback;)Lorg/sqlite/jni/RollbackHookCallback; */ JNIEXPORT jobject JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1rollback_1hook - (JNIEnv *, jclass, jobject, jobject); + (JNIEnv *, jclass, jlong, jobject); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1838,26 +1846,26 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1step /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_stmt_explain - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;I)I + * Signature: (JI)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1stmt_1explain - (JNIEnv *, jclass, jobject, jint); + (JNIEnv *, jclass, jlong, jint); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_stmt_isexplain - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1stmt_1isexplain - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_stmt_readonly - * Signature: (Lorg/sqlite/jni/sqlite3_stmt;)Z + * Signature: (J)Z */ JNIEXPORT jboolean JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1stmt_1readonly - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1886,10 +1894,10 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1strlike /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_system_errno - * Signature: (Lorg/sqlite/jni/sqlite3;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1system_1errno - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1910,18 +1918,18 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1threadsafe /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_total_changes - * Signature: (Lorg/sqlite/jni/sqlite3;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1total_1changes - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_total_changes64 - * Signature: (Lorg/sqlite/jni/sqlite3;)J + * Signature: (J)J */ JNIEXPORT jlong JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1total_1changes64 - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni @@ -1942,153 +1950,182 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1txn_1state /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_update_hook - * Signature: (Lorg/sqlite/jni/sqlite3;Lorg/sqlite/jni/UpdateHookCallback;)Lorg/sqlite/jni/UpdateHookCallback; + * Signature: (JLorg/sqlite/jni/UpdateHookCallback;)Lorg/sqlite/jni/UpdateHookCallback; */ JNIEXPORT jobject JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1update_1hook - (JNIEnv *, jclass, jobject, jobject); + (JNIEnv *, jclass, jlong, jobject); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_blob - * Signature: (Lorg/sqlite/jni/sqlite3_value;)[B + * Signature: (J)[B */ JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1blob - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_bytes - * Signature: (Lorg/sqlite/jni/sqlite3_value;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1bytes - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_bytes16 - * Signature: (Lorg/sqlite/jni/sqlite3_value;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1bytes16 - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_double - * Signature: (Lorg/sqlite/jni/sqlite3_value;)D + * Signature: (J)D */ JNIEXPORT jdouble JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1double - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_dup - * Signature: (Lorg/sqlite/jni/sqlite3_value;)Lorg/sqlite/jni/sqlite3_value; + * Signature: (J)Lorg/sqlite/jni/sqlite3_value; */ JNIEXPORT jobject JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1dup - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_encoding - * Signature: (Lorg/sqlite/jni/sqlite3_value;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1encoding - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_free - * Signature: (Lorg/sqlite/jni/sqlite3_value;)V + * Signature: (J)V */ JNIEXPORT void JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1free - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); + +/* + * Class: org_sqlite_jni_SQLite3Jni + * Method: sqlite3_value_frombind + * Signature: (J)I + */ +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1frombind + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_int - * Signature: (Lorg/sqlite/jni/sqlite3_value;)I + * Signature: (J)I */ JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1int - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_int64 - * Signature: (Lorg/sqlite/jni/sqlite3_value;)J + * Signature: (J)J */ JNIEXPORT jlong JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1int64 - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni * Method: sqlite3_value_java_object - * Signature: (Lorg/sqlite/jni/sqlite3_value;)Ljava/lang/Object; + * Signature: (J)Ljava/lang/Object; */ JNIEXPORT jobject JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1java_1object - (JNIEnv *, jclass, jobject); + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni - * Method: sqlite3_value_text - * Signature: (Lorg/sqlite/jni/sqlite3_value;)[B + * Method: sqlite3_value_nochange + * Signature: (J)I */ -JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1text - (JNIEnv *, jclass, jobject); +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1nochange + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni - * Method: sqlite3_value_text16 - * Signature: (Lorg/sqlite/jni/sqlite3_value;)Ljava/lang/String; + * Method: sqlite3_value_numeric_type + * Signature: (J)I */ -JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1text16 - (JNIEnv *, jclass, jobject); +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1numeric_1type + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni - * Method: sqlite3_value_type - * Signature: (Lorg/sqlite/jni/sqlite3_value;)I + * Method: sqlite3_value_subtype + * Signature: (J)I */ -JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1type - (JNIEnv *, jclass, jobject); +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1subtype + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni - * Method: sqlite3_value_numeric_type - * Signature: (Lorg/sqlite/jni/sqlite3_value;)I + * Method: sqlite3_value_text + * Signature: (J)[B */ -JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1numeric_1type - (JNIEnv *, jclass, jobject); +JNIEXPORT jbyteArray JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1text + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni - * Method: sqlite3_value_nochange - * Signature: (Lorg/sqlite/jni/sqlite3_value;)I + * Method: sqlite3_value_text16 + * Signature: (J)Ljava/lang/String; */ -JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1nochange - (JNIEnv *, jclass, jobject); +JNIEXPORT jstring JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1text16 + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni - * Method: sqlite3_value_frombind - * Signature: (Lorg/sqlite/jni/sqlite3_value;)I + * Method: sqlite3_value_type + * Signature: (J)I */ -JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1frombind - (JNIEnv *, jclass, jobject); +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1type + (JNIEnv *, jclass, jlong); /* * Class: org_sqlite_jni_SQLite3Jni - * Method: sqlite3_value_subtype - * Signature: (Lorg/sqlite/jni/sqlite3_value;)I + * Method: sqlite3_jni_internal_details + * Signature: ()V */ -JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1value_1subtype - (JNIEnv *, jclass, jobject); +JNIEXPORT void JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1jni_1internal_1details + (JNIEnv *, jclass); + +#ifdef __cplusplus +} +#endif +#endif +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class org_sqlite_jni_SQLTester */ +#ifndef _Included_org_sqlite_jni_SQLTester +#define _Included_org_sqlite_jni_SQLTester +#ifdef __cplusplus +extern "C" { +#endif /* - * Class: org_sqlite_jni_SQLite3Jni - * Method: sqlite3_jni_internal_details + * Class: org_sqlite_jni_SQLTester + * Method: strglob + * Signature: ([B[B)I + */ +JNIEXPORT jint JNICALL Java_org_sqlite_jni_SQLTester_strglob + (JNIEnv *, jclass, jbyteArray, jbyteArray); + +/* + * Class: org_sqlite_jni_SQLTester + * Method: installCustomExtensions * Signature: ()V */ -JNIEXPORT void JNICALL Java_org_sqlite_jni_SQLite3Jni_sqlite3_1jni_1internal_1details +JNIEXPORT void JNICALL Java_org_sqlite_jni_SQLTester_installCustomExtensions (JNIEnv *, jclass); #ifdef __cplusplus @@ -2320,32 +2357,3 @@ JNIEXPORT jint JNICALL Java_org_sqlite_jni_fts5_fts5_1tokenizer_xTokenize } #endif #endif -/* DO NOT EDIT THIS FILE - it is machine generated */ -#include <jni.h> -/* Header for class org_sqlite_jni_tester_SQLTester */ - -#ifndef _Included_org_sqlite_jni_tester_SQLTester -#define _Included_org_sqlite_jni_tester_SQLTester -#ifdef __cplusplus -extern "C" { -#endif -/* - * Class: org_sqlite_jni_tester_SQLTester - * Method: strglob - * Signature: ([B[B)I - */ -JNIEXPORT jint JNICALL Java_org_sqlite_jni_tester_SQLTester_strglob - (JNIEnv *, jclass, jbyteArray, jbyteArray); - -/* - * Class: org_sqlite_jni_tester_SQLTester - * Method: installCustomExtensions - * Signature: ()V - */ -JNIEXPORT void JNICALL Java_org_sqlite_jni_tester_SQLTester_installCustomExtensions - (JNIEnv *, jclass); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/ext/jni/src/org/sqlite/jni/NativePointerHolder.java b/ext/jni/src/org/sqlite/jni/NativePointerHolder.java index 251eb7faa..2b0e8cfbd 100644 --- a/ext/jni/src/org/sqlite/jni/NativePointerHolder.java +++ b/ext/jni/src/org/sqlite/jni/NativePointerHolder.java @@ -29,5 +29,18 @@ package org.sqlite.jni; public class NativePointerHolder<ContextType> { //! Only set from JNI, where access permissions don't matter. private volatile long nativePointer = 0; + /** + For use ONLY by package-level APIs which act as proxies for + close/finalize operations. Such ops must call this to zero out + the pointer so that this object is not carrying a stale + pointer. This function returns the prior value of the pointer and + sets it to 0. + */ + final long clearNativePointer() { + final long rv = nativePointer; + nativePointer= 0; + return rv; + } + public final long getNativePointer(){ return nativePointer; } } diff --git a/ext/jni/src/org/sqlite/jni/tester/SQLTester.java b/ext/jni/src/org/sqlite/jni/SQLTester.java index 4a97d4974..b3e184523 100644 --- a/ext/jni/src/org/sqlite/jni/tester/SQLTester.java +++ b/ext/jni/src/org/sqlite/jni/SQLTester.java @@ -12,16 +12,13 @@ ** This file contains the main application entry pointer for the ** SQLTester framework. */ -package org.sqlite.jni.tester; +package org.sqlite.jni; import java.util.List; import java.util.ArrayList; import java.util.Arrays; import java.nio.charset.StandardCharsets; import java.util.regex.*; -import org.sqlite.jni.*; import static org.sqlite.jni.SQLite3Jni.*; -import org.sqlite.jni.sqlite3; - /** Modes for how to escape (or not) column values and names from @@ -150,12 +147,15 @@ class Outer { } /** - This class provides an application which aims to implement the + <p>This class provides an application which aims to implement the rudimentary SQL-driven test tool described in the accompanying {@code test-script-interpreter.md}. - <p>This is a work in progress. - + <p>This class is an internal testing tool, not part of the public + interface but is (A) in the same package as the library because + access permissions require it to be so and (B) the JDK8 javadoc + offers no way to filter individual classes out of the doc + generation process (it can only exclude packages, but see (A)). <p>An instance of this application provides a core set of services which TestScript instances use for processing testing logic. diff --git a/ext/jni/src/org/sqlite/jni/SQLite3Jni.java b/ext/jni/src/org/sqlite/jni/SQLite3Jni.java index 9257afbb6..38aa7aad9 100644 --- a/ext/jni/src/org/sqlite/jni/SQLite3Jni.java +++ b/ext/jni/src/org/sqlite/jni/SQLite3Jni.java @@ -93,6 +93,14 @@ public final class SQLite3Jni { private static native void init(); /** + Returns a nul-terminated copy of s as a byte array, or null if s + is null. + */ + private static byte[] nulTerminateUtf8(String s){ + return null==s ? null : (s+"\0").getBytes(StandardCharsets.UTF_8); + } + + /** Each thread which uses the SQLite3 JNI APIs should call sqlite3_jni_uncache_thread() when it is done with the library - either right before it terminates or when it finishes using the @@ -115,7 +123,7 @@ public final class SQLite3Jni { which client-level code should use to make any informed decisions. */ - public static native boolean sqlite3_java_uncache_thread(); + static native boolean sqlite3_java_uncache_thread(); ////////////////////////////////////////////////////////////////////// // Maintenance reminder: please keep the sqlite3_.... functions @@ -139,7 +147,7 @@ public final class SQLite3Jni { "not a key" value. */ @Canonical - public static native long sqlite3_aggregate_context(sqlite3_context cx, boolean initialize); + static native long sqlite3_aggregate_context(sqlite3_context cx, boolean initialize); /** Functions almost as documented for the C API, with these @@ -158,77 +166,143 @@ public final class SQLite3Jni { <p>See the AutoExtension class docs for more information. */ @Canonical - public static native int sqlite3_auto_extension(@NotNull AutoExtensionCallback callback); + static native int sqlite3_auto_extension(@NotNull AutoExtensionCallback callback); @Canonical - public static native int sqlite3_backup_finish(@NotNull sqlite3_backup b); + static native int sqlite3_backup_finish(@NotNull long ptrToBackup); @Canonical - public static native sqlite3_backup sqlite3_backup_init( + public static int sqlite3_backup_finish(@NotNull sqlite3_backup b){ + return sqlite3_backup_finish(b.clearNativePointer()); + } + + @Canonical + static native sqlite3_backup sqlite3_backup_init( + @NotNull long ptrToDbDest, @NotNull String destTableName, + @NotNull long ptrToDbSrc, @NotNull String srcTableName + ); + + @Canonical + public static sqlite3_backup sqlite3_backup_init( @NotNull sqlite3 dbDest, @NotNull String destTableName, @NotNull sqlite3 dbSrc, @NotNull String srcTableName - ); + ){ + return sqlite3_backup_init( dbDest.getNativePointer(), destTableName, + dbSrc.getNativePointer(), srcTableName ); + } + + @Canonical + static native int sqlite3_backup_pagecount(@NotNull long ptrToBackup); @Canonical - public static native int sqlite3_backup_pagecount(@NotNull sqlite3_backup b); + public static int sqlite3_backup_pagecount(@NotNull sqlite3_backup b){ + return sqlite3_backup_pagecount(b.getNativePointer()); + } @Canonical - public static native int sqlite3_backup_remaining(@NotNull sqlite3_backup b); + static native int sqlite3_backup_remaining(@NotNull long ptrToBackup); @Canonical - public static native int sqlite3_backup_step( - @NotNull sqlite3_backup b, int nPage + public static int sqlite3_backup_remaining(@NotNull sqlite3_backup b){ + return sqlite3_backup_remaining(b.getNativePointer()); + } + + @Canonical + static native int sqlite3_backup_step(@NotNull long ptrToBackup, int nPage); + + @Canonical + public static int sqlite3_backup_step(@NotNull sqlite3_backup b, int nPage){ + return sqlite3_backup_step(b.getNativePointer(), nPage); + } + + @Canonical + static native int sqlite3_bind_blob( + @NotNull long ptrToStmt, int ndx, @Nullable byte[] data, int n ); /** Results are undefined if data is not null and n<0 || n>=data.length. */ @Canonical - public static native int sqlite3_bind_blob( + public static int sqlite3_bind_blob( @NotNull sqlite3_stmt stmt, int ndx, @Nullable byte[] data, int n - ); + ){ + return sqlite3_bind_blob(stmt.getNativePointer(), ndx, data, n); + } public static int sqlite3_bind_blob( @NotNull sqlite3_stmt stmt, int ndx, @Nullable byte[] data ){ return (null==data) - ? sqlite3_bind_null(stmt, ndx) - : sqlite3_bind_blob(stmt, ndx, data, data.length); + ? sqlite3_bind_null(stmt.getNativePointer(), ndx) + : sqlite3_bind_blob(stmt.getNativePointer(), ndx, data, data.length); } @Canonical - public static native int sqlite3_bind_double( + static native int sqlite3_bind_double( + @NotNull long ptrToStmt, int ndx, double v + ); + + @Canonical + public static int sqlite3_bind_double( @NotNull sqlite3_stmt stmt, int ndx, double v + ){ + return sqlite3_bind_double(stmt.getNativePointer(), ndx, v); + } + + @Canonical + static native int sqlite3_bind_int( + @NotNull long ptrToStmt, int ndx, int v ); @Canonical - public static native int sqlite3_bind_int( + public static int sqlite3_bind_int( @NotNull sqlite3_stmt stmt, int ndx, int v + ){ + return sqlite3_bind_int(stmt.getNativePointer(), ndx, v); + } + + @Canonical + static native int sqlite3_bind_int64( + @NotNull long ptrToStmt, int ndx, long v ); @Canonical - public static native int sqlite3_bind_int64( - @NotNull sqlite3_stmt stmt, int ndx, long v + public static int sqlite3_bind_int64(@NotNull sqlite3_stmt stmt, int ndx, long v){ + return sqlite3_bind_int64( stmt.getNativePointer(), ndx, v ); + } + + static native int sqlite3_bind_java_object( + @NotNull long ptrToStmt, int ndx, @Nullable Object o ); /** - Binds the given object at the given index. + Binds the given object at the given index. If o is null then this behaves like + sqlite3_bind_null(). @see #sqlite3_result_java_object */ - public static native int sqlite3_bind_java_object( - @NotNull sqlite3_stmt cx, int ndx, @Nullable Object o - ); + public static int sqlite3_bind_java_object( + @NotNull sqlite3_stmt stmt, int ndx, @Nullable Object o + ){ + return sqlite3_bind_java_object(stmt.getNativePointer(), ndx, o); + } @Canonical - public static native int sqlite3_bind_null( - @NotNull sqlite3_stmt stmt, int ndx - ); + static native int sqlite3_bind_null(@NotNull long ptrToStmt, int ndx); @Canonical - public static native int sqlite3_bind_parameter_count( - @NotNull sqlite3_stmt stmt - ); + public static int sqlite3_bind_null(@NotNull sqlite3_stmt stmt, int ndx){ + return sqlite3_bind_null(stmt.getNativePointer(), ndx); + } + + @Canonical + static native int sqlite3_bind_parameter_count(@NotNull long ptrToStmt); + + @Canonical + public static int sqlite3_bind_parameter_count(@NotNull sqlite3_stmt stmt){ + return sqlite3_bind_parameter_count(stmt.getNativePointer()); + } /** Requires that paramName be a NUL-terminated UTF-8 string. @@ -241,21 +315,31 @@ public final class SQLite3Jni { public-facing one. */ @Canonical - private static native int sqlite3_bind_parameter_index( - @NotNull sqlite3_stmt stmt, @NotNull byte[] paramName + static native int sqlite3_bind_parameter_index( + @NotNull long ptrToStmt, @NotNull byte[] paramName ); @Canonical public static int sqlite3_bind_parameter_index( @NotNull sqlite3_stmt stmt, @NotNull String paramName ){ - final byte[] utf8 = (paramName+"\0").getBytes(StandardCharsets.UTF_8); - return sqlite3_bind_parameter_index(stmt, utf8); + final byte[] utf8 = nulTerminateUtf8(paramName); + return null==utf8 ? 0 : sqlite3_bind_parameter_index(stmt.getNativePointer(), utf8); + } + + @Canonical + static native String sqlite3_bind_parameter_name( + @NotNull long ptrToStmt, int index + ); + + @Canonical + public static String sqlite3_bind_parameter_name(@NotNull sqlite3_stmt stmt, int index){ + return sqlite3_bind_parameter_name(stmt.getNativePointer(), index); } @Canonical - public static native String sqlite3_bind_parameter_name( - @NotNull sqlite3_stmt stmt, int index + static native int sqlite3_bind_text( + @NotNull long ptrToStmt, int ndx, @Nullable byte[] utf8, int maxBytes ); /** @@ -268,9 +352,11 @@ public final class SQLite3Jni { undefined if data is not null and does not contain a NUL byte. */ @Canonical - public static native int sqlite3_bind_text( + public static int sqlite3_bind_text( @NotNull sqlite3_stmt stmt, int ndx, @Nullable byte[] utf8, int maxBytes - ); + ){ + return sqlite3_bind_text(stmt.getNativePointer(), ndx, utf8, maxBytes); + } /** Converts data, if not null, to a UTF-8-encoded byte array and @@ -280,9 +366,9 @@ public final class SQLite3Jni { public static int sqlite3_bind_text( @NotNull sqlite3_stmt stmt, int ndx, @Nullable String data ){ - if(null == data) return sqlite3_bind_null(stmt, ndx); + if( null==data ) return sqlite3_bind_null(stmt.getNativePointer(), ndx); final byte[] utf8 = data.getBytes(StandardCharsets.UTF_8); - return sqlite3_bind_text(stmt, ndx, utf8, utf8.length); + return sqlite3_bind_text(stmt.getNativePointer(), ndx, utf8, utf8.length); } /** @@ -292,19 +378,26 @@ public final class SQLite3Jni { @NotNull sqlite3_stmt stmt, int ndx, @Nullable byte[] utf8 ){ return (null == utf8) - ? sqlite3_bind_null(stmt, ndx) - : sqlite3_bind_text(stmt, ndx, utf8, utf8.length); + ? sqlite3_bind_null(stmt.getNativePointer(), ndx) + : sqlite3_bind_text(stmt.getNativePointer(), ndx, utf8, utf8.length); } + @Canonical + static native int sqlite3_bind_text16( + @NotNull long ptrToStmt, int ndx, @Nullable byte[] data, int maxBytes + ); + /** Identical to the sqlite3_bind_text() overload with the same signature but requires that its input be encoded in UTF-16 in platform byte order. */ @Canonical - public static native int sqlite3_bind_text16( + public static int sqlite3_bind_text16( @NotNull sqlite3_stmt stmt, int ndx, @Nullable byte[] data, int maxBytes - ); + ){ + return sqlite3_bind_text16(stmt.getNativePointer(), ndx, data, maxBytes); + } /** Converts its string argument to UTF-16 and binds it as such, returning @@ -316,7 +409,7 @@ public final class SQLite3Jni { ){ if(null == data) return sqlite3_bind_null(stmt, ndx); final byte[] bytes = data.getBytes(StandardCharsets.UTF_16); - return sqlite3_bind_text16(stmt, ndx, bytes, bytes.length); + return sqlite3_bind_text16(stmt.getNativePointer(), ndx, bytes, bytes.length); } /** @@ -328,33 +421,61 @@ public final class SQLite3Jni { @NotNull sqlite3_stmt stmt, int ndx, @Nullable byte[] data ){ return (null == data) - ? sqlite3_bind_null(stmt, ndx) - : sqlite3_bind_text16(stmt, ndx, data, data.length); + ? sqlite3_bind_null(stmt.getNativePointer(), ndx) + : sqlite3_bind_text16(stmt.getNativePointer(), ndx, data, data.length); } @Canonical - public static native int sqlite3_bind_zeroblob( - @NotNull sqlite3_stmt stmt, int ndx, int n - ); + static native int sqlite3_bind_zeroblob(@NotNull long ptrToStmt, int ndx, int n); @Canonical - public static native int sqlite3_bind_zeroblob64( - @NotNull sqlite3_stmt stmt, int ndx, long n + public static int sqlite3_bind_zeroblob(@NotNull sqlite3_stmt stmt, int ndx, int n){ + return sqlite3_bind_zeroblob(stmt.getNativePointer(), ndx, n); + } + + @Canonical + static native int sqlite3_bind_zeroblob64( + @NotNull long ptrToStmt, int ndx, long n ); @Canonical - public static native int sqlite3_blob_bytes(@NotNull sqlite3_blob blob); + public static int sqlite3_bind_zeroblob64(@NotNull sqlite3_stmt stmt, int ndx, long n){ + return sqlite3_bind_zeroblob64(stmt.getNativePointer(), ndx, n); + } @Canonical - public static native int sqlite3_blob_close(@Nullable sqlite3_blob blob); + static native int sqlite3_blob_bytes(@NotNull long ptrToBlob); @Canonical - public static native int sqlite3_blob_open( - @NotNull sqlite3 db, @NotNull String dbName, + public static int sqlite3_blob_bytes(@NotNull sqlite3_blob blob){ + return sqlite3_blob_bytes(blob.getNativePointer()); + } + + @Canonical + static native int sqlite3_blob_close(@Nullable long ptrToBlob); + + @Canonical + public static int sqlite3_blob_close(@Nullable sqlite3_blob blob){ + return sqlite3_blob_close(blob.clearNativePointer()); + } + + @Canonical + static native int sqlite3_blob_open( + @NotNull long ptrToDb, @NotNull String dbName, @NotNull String tableName, @NotNull String columnName, long iRow, int flags, @NotNull OutputPointer.sqlite3_blob out ); + @Canonical + public static int sqlite3_blob_open( + @NotNull sqlite3 db, @NotNull String dbName, + @NotNull String tableName, @NotNull String columnName, + long iRow, int flags, @NotNull OutputPointer.sqlite3_blob out + ){ + return sqlite3_blob_open(db.getNativePointer(), dbName, tableName, + columnName, iRow, flags, out); + } + /** Convenience overload. */ @@ -363,23 +484,48 @@ public final class SQLite3Jni { @NotNull String tableName, @NotNull String columnName, long iRow, int flags ){ final OutputPointer.sqlite3_blob out = new OutputPointer.sqlite3_blob(); - sqlite3_blob_open(db, dbName, tableName, columnName, iRow, flags, out); + sqlite3_blob_open(db.getNativePointer(), dbName, tableName, columnName, + iRow, flags, out); return out.take(); }; @Canonical - public static native int sqlite3_blob_read( + static native int sqlite3_blob_read( + @NotNull long ptrToBlob, @NotNull byte[] target, int iOffset + ); + + @Canonical + public static int sqlite3_blob_read( @NotNull sqlite3_blob b, @NotNull byte[] target, int iOffset + ){ + return sqlite3_blob_read(b.getNativePointer(), target, iOffset); + } + + @Canonical + static native int sqlite3_blob_reopen( + @NotNull long ptrToBlob, long newRowId ); @Canonical - public static native int sqlite3_blob_reopen( - @NotNull sqlite3_blob out, long newRowId + public static int sqlite3_blob_reopen(@NotNull sqlite3_blob b, long newRowId){ + return sqlite3_blob_reopen(b.getNativePointer(), newRowId); + } + + @Canonical + static native int sqlite3_blob_write( + @NotNull long ptrToBlob, @NotNull byte[] bytes, int iOffset ); @Canonical - public static native int sqlite3_blob_write( - @NotNull sqlite3_blob out, @NotNull byte[] bytes, int iOffset + public static int sqlite3_blob_write( + @NotNull sqlite3_blob b, @NotNull byte[] bytes, int iOffset + ){ + return sqlite3_blob_write(b.getNativePointer(), bytes, iOffset); + } + + @Canonical + static native int sqlite3_busy_handler( + @NotNull long ptrToDb, @Nullable BusyHandlerCallback handler ); /** @@ -388,100 +534,154 @@ public final class SQLite3Jni { function. Pass it a null handler to clear the busy handler. */ @Canonical - public static native int sqlite3_busy_handler( + public static int sqlite3_busy_handler( @NotNull sqlite3 db, @Nullable BusyHandlerCallback handler - ); + ){ + return sqlite3_busy_handler(db.getNativePointer(), handler); + } @Canonical - public static native int sqlite3_busy_timeout( - @NotNull sqlite3 db, int ms - ); + static native int sqlite3_busy_timeout(@NotNull long ptrToDb, int ms); + + @Canonical + public static int sqlite3_busy_timeout(@NotNull sqlite3 db, int ms){ + return sqlite3_busy_timeout(db.getNativePointer(), ms); + } @Canonical - public static native boolean sqlite3_cancel_auto_extension( + static native boolean sqlite3_cancel_auto_extension( @NotNull AutoExtensionCallback ax ); @Canonical - public static native int sqlite3_changes( - @NotNull sqlite3 db - ); + static native int sqlite3_changes(@NotNull long ptrToDb); @Canonical - public static native long sqlite3_changes64( - @NotNull sqlite3 db - ); + public static int sqlite3_changes(@NotNull sqlite3 db){ + return sqlite3_changes(db.getNativePointer()); + } @Canonical - public static native int sqlite3_clear_bindings( - @NotNull sqlite3_stmt stmt - ); + static native long sqlite3_changes64(@NotNull long ptrToDb); @Canonical - public static native int sqlite3_close( - @Nullable sqlite3 db - ); + public static long sqlite3_changes64(@NotNull sqlite3 db){ + return sqlite3_changes64(db.getNativePointer()); + } @Canonical - public static native int sqlite3_close_v2( - @Nullable sqlite3 db - ); + static native int sqlite3_clear_bindings(@NotNull long ptrToStmt); @Canonical - public static native byte[] sqlite3_column_blob( - @NotNull sqlite3_stmt stmt, int ndx - ); + public static int sqlite3_clear_bindings(@NotNull sqlite3_stmt stmt){ + return sqlite3_clear_bindings(stmt.getNativePointer()); + } @Canonical - public static native int sqlite3_column_bytes( - @NotNull sqlite3_stmt stmt, int ndx - ); + static native int sqlite3_close(@Nullable long ptrToDb); @Canonical - public static native int sqlite3_column_bytes16( - @NotNull sqlite3_stmt stmt, int ndx - ); + public static int sqlite3_close(@Nullable sqlite3 db){ + int rc = 0; + if( null!=db ){ + rc = sqlite3_close(db.getNativePointer()); + if( 0==rc ) db.clearNativePointer(); + } + return rc; + } @Canonical - public static native int sqlite3_column_count( - @NotNull sqlite3_stmt stmt - ); + static native int sqlite3_close_v2(@Nullable long ptrToDb); @Canonical - public static native double sqlite3_column_double( - @NotNull sqlite3_stmt stmt, int ndx - ); + public static int sqlite3_close_v2(@Nullable sqlite3 db){ + return db==null ? 0 : sqlite3_close_v2(db.clearNativePointer()); + } @Canonical - public static native int sqlite3_column_int( + static native byte[] sqlite3_column_blob( @NotNull sqlite3_stmt stmt, int ndx ); @Canonical - public static native long sqlite3_column_int64( - @NotNull sqlite3_stmt stmt, int ndx - ); + static native int sqlite3_column_bytes(@NotNull long ptrToStmt, int ndx); @Canonical - public static native String sqlite3_column_name( - @NotNull sqlite3_stmt stmt, int ndx - ); + public static int sqlite3_column_bytes(@NotNull sqlite3_stmt stmt, int ndx){ + return sqlite3_column_bytes(stmt.getNativePointer(), ndx); + } + + @Canonical + static native int sqlite3_column_bytes16(@NotNull long ptrToStmt, int ndx); + + @Canonical + public static int sqlite3_column_bytes16(@NotNull sqlite3_stmt stmt, int ndx){ + return sqlite3_column_bytes16(stmt.getNativePointer(), ndx); + } + + @Canonical + static native int sqlite3_column_count(@NotNull long ptrToStmt); + + @Canonical + public static int sqlite3_column_count(@NotNull sqlite3_stmt stmt){ + return sqlite3_column_count(stmt.getNativePointer()); + } @Canonical - public static native String sqlite3_column_database_name( + static native String sqlite3_column_decltype(@NotNull long ptrToStmt, int ndx); + + @Canonical + public static String sqlite3_column_decltype(@NotNull sqlite3_stmt stmt, int ndx){ + return sqlite3_column_decltype(stmt.getNativePointer(), ndx); + } + + @Canonical + static native double sqlite3_column_double( @NotNull sqlite3_stmt stmt, int ndx ); @Canonical - public static native String sqlite3_column_origin_name( + static native int sqlite3_column_int( @NotNull sqlite3_stmt stmt, int ndx ); @Canonical - public static native String sqlite3_column_table_name( + static native long sqlite3_column_int64( @NotNull sqlite3_stmt stmt, int ndx ); + @Canonical + static native String sqlite3_column_name(@NotNull long ptrToStmt, int ndx); + + @Canonical + public static String sqlite3_column_name(@NotNull sqlite3_stmt stmt, int ndx){ + return sqlite3_column_name(stmt.getNativePointer(), ndx); + } + + @Canonical + static native String sqlite3_column_database_name(@NotNull long ptrToStmt, int ndx); + + @Canonical + public static String sqlite3_column_database_name(@NotNull sqlite3_stmt stmt, int ndx){ + return sqlite3_column_database_name(stmt.getNativePointer(), ndx); + } + + @Canonical + static native String sqlite3_column_origin_name(@NotNull long ptrToStmt, int ndx); + + @Canonical + public static String sqlite3_column_origin_name(@NotNull sqlite3_stmt stmt, int ndx){ + return sqlite3_column_origin_name(stmt.getNativePointer(), ndx); + } + + @Canonical + static native String sqlite3_column_table_name(@NotNull long ptrToStmt, int ndx); + + @Canonical + public static String sqlite3_column_table_name(@NotNull sqlite3_stmt stmt, int ndx){ + return sqlite3_column_table_name(stmt.getNativePointer(), ndx); + } + /** Functions identially to the C API, and this note is just to stress that the returned bytes are encoded as UTF-8. It returns @@ -491,12 +691,12 @@ public final class SQLite3Jni { @see #sqlite3_column_text16(sqlite3_stmt,int) */ @Canonical - public static native byte[] sqlite3_column_text( + static native byte[] sqlite3_column_text( @NotNull sqlite3_stmt stmt, int ndx ); @Canonical - public static native String sqlite3_column_text16( + static native String sqlite3_column_text16( @NotNull sqlite3_stmt stmt, int ndx ); @@ -538,13 +738,21 @@ public final class SQLite3Jni { // } @Canonical - public static native int sqlite3_column_type( + static native int sqlite3_column_type(@NotNull long ptrToStmt, int ndx); + + @Canonical + public static int sqlite3_column_type(@NotNull sqlite3_stmt stmt, int ndx){ + return sqlite3_column_type(stmt.getNativePointer(), ndx); + } + + @Canonical + static native sqlite3_value sqlite3_column_value( @NotNull sqlite3_stmt stmt, int ndx ); @Canonical - public static native sqlite3_value sqlite3_column_value( - @NotNull sqlite3_stmt stmt, int ndx + static native int sqlite3_collation_needed( + @NotNull long ptrToDb, @Nullable CollationNeededCallback callback ); /** @@ -552,40 +760,46 @@ public final class SQLite3Jni { Java's string type is inherently compatible with that interface. */ @Canonical - public static native int sqlite3_collation_needed( + public static int sqlite3_collation_needed( @NotNull sqlite3 db, @Nullable CollationNeededCallback callback + ){ + return sqlite3_collation_needed(db.getNativePointer(), callback); + } + + @Canonical + static native CommitHookCallback sqlite3_commit_hook( + @NotNull long ptrToDb, @Nullable CommitHookCallback hook ); @Canonical - public static native CommitHookCallback sqlite3_commit_hook( + public static CommitHookCallback sqlite3_commit_hook( @NotNull sqlite3 db, @Nullable CommitHookCallback hook - ); + ){ + return sqlite3_commit_hook(db.getNativePointer(), hook); + } @Canonical - public static native String sqlite3_compileoption_get( - int n - ); + static native String sqlite3_compileoption_get(int n); @Canonical - public static native boolean sqlite3_compileoption_used( - @NotNull String optName - ); + static native boolean sqlite3_compileoption_used(String optName); /** This implementation is private because it's too easy to pass it - non-NUL-terminated arrays. + non-NUL-terminated byte arrays from client code. */ @Canonical - private static native int sqlite3_complete( + static native int sqlite3_complete( @NotNull byte[] nulTerminatedUtf8Sql ); + /** + Unlike this C API, this returns SQLITE_MISUSE if its argument is + null (as opposed to invoking UB). + */ @Canonical() - public static int sqlite3_complete(@NotNull String sql){ - /* Design note: we don't implement this in native code because we - won't get a NUL-terminated string there unless we make our own - copy to add a terminator. That's much easier to do here. */ - return sqlite3_complete( (sql+"\0").getBytes(StandardCharsets.UTF_8) ); + static int sqlite3_complete(@NotNull String sql){ + return sqlite3_complete( nulTerminateUtf8(sql) ); } @@ -607,7 +821,7 @@ public final class SQLite3Jni { @Canonical(comment="Option subset: "+ "SQLITE_CONFIG_SINGLETHREAD, SQLITE_CONFIG_MULTITHREAD, "+ "SQLITE_CONFIG_SERIALIZED") - public static native int sqlite3_config(int op); + static native int sqlite3_config(int op); /** If the native library was built with SQLITE_ENABLE_SQLLOG defined @@ -624,22 +838,30 @@ 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 ); + static native int sqlite3_config( @Nullable ConfigSqllogCallback logger ); /** The sqlite3_config() overload for handling the SQLITE_CONFIG_LOG option. */ @Canonical(comment="Option subset: SQLITE_CONFIG_LOG") - public static native int sqlite3_config( @Nullable ConfigLogCallback logger ); + static native int sqlite3_config( @Nullable ConfigLogCallback logger ); + /** + Unlike this C API, this returns null if its argument is + null (as opposed to invoking UB). + */ @Canonical - public static native sqlite3 sqlite3_context_db_handle( + static native sqlite3 sqlite3_context_db_handle( @NotNull sqlite3_context cx ); + /** + Unlike this C API, this returns SQLITE_MISUSE if its db or name + arguments are null (as opposed to invoking UB). + */ @Canonical - public static native int sqlite3_create_collation( + static native int sqlite3_create_collation( @NotNull sqlite3 db, @NotNull String name, int eTextRep, @NotNull CollationCallback col ); @@ -651,25 +873,34 @@ public final class SQLite3Jni { depends on which methods the final argument implements. See SQLFunction's subclasses (ScalarFunction, AggregateFunction<T>, and WindowFunction<T>) for details. + + Unlike this C API, this returns SQLITE_MISUSE null if its db or + functionName arguments are null (as opposed to invoking UB). */ @Canonical - public static native int sqlite3_create_function( + 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 - ); + static native int sqlite3_data_count(@NotNull long ptrToStmt); + + @Canonical + public static int sqlite3_data_count(@NotNull sqlite3_stmt stmt){ + return sqlite3_data_count(stmt.getNativePointer()); + } /** Overload for sqlite3_db_config() calls which take (int,int*) variadic arguments. Returns SQLITE_MISUSE if op is not one of the SQLITE_DBCONFIG_... options which uses this call form. + + Unlike this C API, this returns SQLITE_MISUSE if its db argument + are null (as opposed to invoking UB). */ @Canonical - public static native int sqlite3_db_config( + static native int sqlite3_db_config( @NotNull sqlite3 db, int op, int onOff, @Nullable OutputPointer.Int32 out ); @@ -681,95 +912,115 @@ public final class SQLite3Jni { extended in future versions. */ @Canonical(comment="Supports only a subset of options.") - public static native int sqlite3_db_config( + static native int sqlite3_db_config( @NotNull sqlite3 db, int op, @NotNull String val ); @Canonical - public static native String sqlite3_db_filename( + static native String sqlite3_db_filename( @NotNull sqlite3 db, @NotNull String dbName ); @Canonical - public static native sqlite3 sqlite3_db_handle( @NotNull sqlite3_stmt stmt ); + static native sqlite3 sqlite3_db_handle(@NotNull sqlite3_stmt stmt); @Canonical - public static native int sqlite3_db_release_memory(sqlite3 db); + static native int sqlite3_db_release_memory(sqlite3 db); @Canonical - public static native int sqlite3_db_status( + 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); + static native int sqlite3_errcode(@NotNull sqlite3 db); @Canonical - public static native String sqlite3_errmsg16(@NotNull sqlite3 db); + static native String sqlite3_errmsg16(@NotNull sqlite3 db); @Canonical - public static native String sqlite3_errstr(int resultCode); + static native int sqlite3_error_offset(@NotNull long ptrToDb); + + /** + 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 int sqlite3_error_offset(@NotNull sqlite3 db){ + return sqlite3_error_offset(db.getNativePointer()); + } @Canonical - public static native String sqlite3_expanded_sql(@NotNull sqlite3_stmt stmt); + static native String sqlite3_errstr(int resultCode); @Canonical - public static native int sqlite3_extended_errcode(@NotNull sqlite3 db); + static native String sqlite3_expanded_sql(@NotNull sqlite3_stmt stmt); + + @Canonical + static native int sqlite3_extended_errcode(@NotNull long ptrToDb); + + @Canonical + public static int sqlite3_extended_errcode(@NotNull sqlite3 db){ + return sqlite3_extended_errcode(db.getNativePointer()); + } @Canonical - public static native boolean sqlite3_extended_result_codes( + static native boolean sqlite3_extended_result_codes( @NotNull sqlite3 db, boolean onoff ); @Canonical - public static native boolean sqlite3_get_autocommit(@NotNull sqlite3 db); + static native boolean sqlite3_get_autocommit(@NotNull long ptrToDb); @Canonical - public static native Object sqlite3_get_auxdata( + public static boolean sqlite3_get_autocommit(@NotNull sqlite3 db){ + return sqlite3_get_autocommit(db.getNativePointer()); + } + + @Canonical + static native Object sqlite3_get_auxdata( @NotNull sqlite3_context cx, int n ); - /** - 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); + static native int sqlite3_finalize(long ptrToStmt); @Canonical - public static native int sqlite3_finalize(@NotNull sqlite3_stmt stmt); + public static int sqlite3_finalize(@NotNull sqlite3_stmt stmt){ + return null==stmt ? 0 : sqlite3_finalize(stmt.clearNativePointer()); + } @Canonical - public static native int sqlite3_initialize(); + static native int sqlite3_initialize(); @Canonical - public static native void sqlite3_interrupt(@NotNull sqlite3 db); + static native void sqlite3_interrupt(@NotNull sqlite3 db); @Canonical - public static native boolean sqlite3_is_interrupted(@NotNull sqlite3 db); + static native boolean sqlite3_is_interrupted(@NotNull sqlite3 db); @Canonical - public static native boolean sqlite3_keyword_check(@NotNull String word); + static native boolean sqlite3_keyword_check(@NotNull String word); @Canonical - public static native int sqlite3_keyword_count(); + static native int sqlite3_keyword_count(); @Canonical - public static native String sqlite3_keyword_name(int index); + static native String sqlite3_keyword_name(int index); @Canonical - public static native long sqlite3_last_insert_rowid(@NotNull sqlite3 db); + static native long sqlite3_last_insert_rowid(@NotNull sqlite3 db); @Canonical - public static native String sqlite3_libversion(); + static native String sqlite3_libversion(); @Canonical - public static native int sqlite3_libversion_number(); + static native int sqlite3_libversion_number(); @Canonical - public static native int sqlite3_limit(@NotNull sqlite3 db, int id, int newVal); + static native int sqlite3_limit(@NotNull sqlite3 db, int id, int newVal); /** Works like its C counterpart and makes the native pointer of the @@ -785,7 +1036,7 @@ public final class SQLite3Jni { db handle. */ @Canonical - public static native int sqlite3_open( + static native int sqlite3_open( @Nullable String filename, @NotNull OutputPointer.sqlite3 ppDb ); @@ -804,7 +1055,7 @@ public final class SQLite3Jni { }; @Canonical - public static native int sqlite3_open_v2( + static native int sqlite3_open_v2( @Nullable String filename, @NotNull OutputPointer.sqlite3 ppDb, int flags, @Nullable String zVfs ); @@ -849,8 +1100,8 @@ public final class SQLite3Jni { real utility. */ @Canonical - private static native int sqlite3_prepare( - @NotNull sqlite3 db, @NotNull byte[] sqlUtf8, int maxBytes, + static native int sqlite3_prepare( + @NotNull long ptrToDb, @NotNull byte[] sqlUtf8, int maxBytes, @NotNull OutputPointer.sqlite3_stmt outStmt, @Nullable OutputPointer.Int32 pTailOffset ); @@ -869,14 +1120,16 @@ public final class SQLite3Jni { @NotNull OutputPointer.sqlite3_stmt outStmt, @Nullable OutputPointer.Int32 pTailOffset ){ - return sqlite3_prepare(db, sqlUtf8, sqlUtf8.length, outStmt, pTailOffset); + return sqlite3_prepare(db.getNativePointer(), sqlUtf8, sqlUtf8.length, + outStmt, pTailOffset); } public static int sqlite3_prepare( @NotNull sqlite3 db, @NotNull byte[] sqlUtf8, @NotNull OutputPointer.sqlite3_stmt outStmt ){ - return sqlite3_prepare(db, sqlUtf8, sqlUtf8.length, outStmt, null); + return sqlite3_prepare(db.getNativePointer(), sqlUtf8, sqlUtf8.length, + outStmt, null); } public static int sqlite3_prepare( @@ -884,7 +1137,8 @@ public final class SQLite3Jni { @NotNull OutputPointer.sqlite3_stmt outStmt ){ final byte[] utf8 = sql.getBytes(StandardCharsets.UTF_8); - return sqlite3_prepare(db, utf8, utf8.length, outStmt, null); + return sqlite3_prepare(db.getNativePointer(), utf8, utf8.length, + outStmt, null); } /** @@ -906,8 +1160,8 @@ public final class SQLite3Jni { @see #sqlite3_prepare */ @Canonical - private static native int sqlite3_prepare_v2( - @NotNull sqlite3 db, @NotNull byte[] sqlUtf8, int maxBytes, + static native int sqlite3_prepare_v2( + @NotNull long ptrToDb, @NotNull byte[] sqlUtf8, int maxBytes, @NotNull OutputPointer.sqlite3_stmt outStmt, @Nullable OutputPointer.Int32 pTailOffset ); @@ -923,14 +1177,16 @@ public final class SQLite3Jni { @NotNull OutputPointer.sqlite3_stmt outStmt, @Nullable OutputPointer.Int32 pTailOffset ){ - return sqlite3_prepare_v2(db, sqlUtf8, sqlUtf8.length, outStmt, pTailOffset); + return sqlite3_prepare_v2(db.getNativePointer(), sqlUtf8, sqlUtf8.length, + outStmt, pTailOffset); } public static int sqlite3_prepare_v2( @NotNull sqlite3 db, @NotNull byte[] sqlUtf8, @NotNull OutputPointer.sqlite3_stmt outStmt ){ - return sqlite3_prepare_v2(db, sqlUtf8, sqlUtf8.length, outStmt, null); + return sqlite3_prepare_v2(db.getNativePointer(), sqlUtf8, sqlUtf8.length, + outStmt, null); } public static int sqlite3_prepare_v2( @@ -938,7 +1194,8 @@ public final class SQLite3Jni { @NotNull OutputPointer.sqlite3_stmt outStmt ){ final byte[] utf8 = sql.getBytes(StandardCharsets.UTF_8); - return sqlite3_prepare_v2(db, utf8, utf8.length, outStmt, null); + return sqlite3_prepare_v2(db.getNativePointer(), utf8, utf8.length, + outStmt, null); } /** @@ -957,8 +1214,8 @@ public final class SQLite3Jni { @see #sqlite3_prepare */ @Canonical - private static native int sqlite3_prepare_v3( - @NotNull sqlite3 db, @NotNull byte[] sqlUtf8, int maxBytes, + static native int sqlite3_prepare_v3( + @NotNull long ptrToDb, @NotNull byte[] sqlUtf8, int maxBytes, int prepFlags, @NotNull OutputPointer.sqlite3_stmt outStmt, @Nullable OutputPointer.Int32 pTailOffset ); @@ -974,7 +1231,8 @@ public final class SQLite3Jni { @NotNull OutputPointer.sqlite3_stmt outStmt, @Nullable OutputPointer.Int32 pTailOffset ){ - return sqlite3_prepare_v3(db, sqlUtf8, sqlUtf8.length, prepFlags, outStmt, pTailOffset); + return sqlite3_prepare_v3(db.getNativePointer(), sqlUtf8, sqlUtf8.length, + prepFlags, outStmt, pTailOffset); } /** @@ -985,7 +1243,8 @@ public final class SQLite3Jni { @NotNull sqlite3 db, @NotNull byte[] sqlUtf8, int prepFlags, @NotNull OutputPointer.sqlite3_stmt outStmt ){ - return sqlite3_prepare_v3(db, sqlUtf8, sqlUtf8.length, prepFlags, outStmt, null); + return sqlite3_prepare_v3(db.getNativePointer(), sqlUtf8, sqlUtf8.length, + prepFlags, outStmt, null); } /** @@ -998,7 +1257,8 @@ public final class SQLite3Jni { @NotNull OutputPointer.sqlite3_stmt outStmt ){ final byte[] utf8 = sql.getBytes(StandardCharsets.UTF_8); - return sqlite3_prepare_v3(db, utf8, utf8.length, prepFlags, outStmt, null); + return sqlite3_prepare_v3(db.getNativePointer(), utf8, utf8.length, + prepFlags, outStmt, null); } /** @@ -1109,6 +1369,8 @@ public final class SQLite3Jni { return sqlite3_prepare_multi(db, sql, 0, p); } + @Canonical + static native int sqlite3_preupdate_blobwrite(@NotNull long ptrToDb); /** If the C API was built with SQLITE_ENABLE_PREUPDATE_HOOK defined, this @@ -1116,21 +1378,40 @@ public final class SQLite3Jni { SQLITE_MISUSE with no side effects. */ @Canonical - public static native int sqlite3_preupdate_blobwrite(@NotNull sqlite3 db); + public static int sqlite3_preupdate_blobwrite(@NotNull sqlite3 db){ + return sqlite3_preupdate_blobwrite(db.getNativePointer()); + } + + @Canonical + static native int sqlite3_preupdate_count(@NotNull long ptrToDb); + /** 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); + public static int sqlite3_preupdate_count(@NotNull sqlite3 db){ + return sqlite3_preupdate_count(db.getNativePointer()); + } + + @Canonical + static native int sqlite3_preupdate_depth(@NotNull long ptrToDb); + /** 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); + public static int sqlite3_preupdate_depth(@NotNull sqlite3 db){ + return sqlite3_preupdate_depth(db.getNativePointer()); + } + + @Canonical + static native PreupdateHookCallback sqlite3_preupdate_hook( + @NotNull long ptrToDb, @Nullable PreupdateHookCallback hook + ); /** If the C API was built with SQLITE_ENABLE_PREUPDATE_HOOK defined, this @@ -1138,9 +1419,15 @@ public final class SQLite3Jni { with no side effects. */ @Canonical - public static native PreupdateHookCallback sqlite3_preupdate_hook( + public static PreupdateHookCallback sqlite3_preupdate_hook( @NotNull sqlite3 db, @Nullable PreupdateHookCallback hook - ); + ){ + return sqlite3_preupdate_hook(db.getNativePointer(), hook); + } + + @Canonical + static native int sqlite3_preupdate_new(@NotNull long ptrToDb, int col, + @NotNull OutputPointer.sqlite3_value out); /** If the C API was built with SQLITE_ENABLE_PREUPDATE_HOOK defined, @@ -1148,8 +1435,10 @@ public final class SQLite3Jni { 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); + public static int sqlite3_preupdate_new(@NotNull sqlite3 db, int col, + @NotNull OutputPointer.sqlite3_value out){ + return sqlite3_preupdate_new(db.getNativePointer(), col, out); + } /** Convenience wrapper for the 3-arg sqlite3_preupdate_new() which returns @@ -1157,18 +1446,24 @@ public final class SQLite3Jni { */ public static sqlite3_value sqlite3_preupdate_new(@NotNull sqlite3 db, int col){ final OutputPointer.sqlite3_value out = new OutputPointer.sqlite3_value(); - sqlite3_preupdate_new(db, col, out); + sqlite3_preupdate_new(db.getNativePointer(), col, out); return out.take(); } + @Canonical + static native int sqlite3_preupdate_old(@NotNull long ptrToDb, int col, + @NotNull OutputPointer.sqlite3_value out); + /** If the C API was built with SQLITE_ENABLE_PREUPDATE_HOOK defined, 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); + public static int sqlite3_preupdate_old(@NotNull sqlite3 db, int col, + @NotNull OutputPointer.sqlite3_value out){ + return sqlite3_preupdate_old(db.getNativePointer(), col, out); + } /** Convenience wrapper for the 3-arg sqlite3_preupdate_old() which returns @@ -1176,23 +1471,23 @@ public final class SQLite3Jni { */ public static sqlite3_value sqlite3_preupdate_old(@NotNull sqlite3 db, int col){ final OutputPointer.sqlite3_value out = new OutputPointer.sqlite3_value(); - sqlite3_preupdate_old(db, col, out); + sqlite3_preupdate_old(db.getNativePointer(), col, out); return out.take(); } @Canonical - public static native void sqlite3_progress_handler( + static native void sqlite3_progress_handler( @NotNull sqlite3 db, int n, @Nullable ProgressHandlerCallback h ); @Canonical - public static native void sqlite3_randomness(byte[] target); + static native void sqlite3_randomness(byte[] target); @Canonical - public static native int sqlite3_release_memory(int n); + static native int sqlite3_release_memory(int n); @Canonical - public static native int sqlite3_reset(@NotNull sqlite3_stmt stmt); + static native int sqlite3_reset(@NotNull sqlite3_stmt stmt); /** Works like the C API except that it has no side effects if auto @@ -1200,10 +1495,10 @@ public final class SQLite3Jni { extensions cannot be manipulated while it is being traversed.) */ @Canonical - public static native void sqlite3_reset_auto_extension(); + static native void sqlite3_reset_auto_extension(); @Canonical - public static native void sqlite3_result_double( + static native void sqlite3_result_double( @NotNull sqlite3_context cx, double v ); @@ -1215,7 +1510,7 @@ public final class SQLite3Jni { complaint about the invalid argument. */ @Canonical - private static native void sqlite3_result_error( + static native void sqlite3_result_error( @NotNull sqlite3_context cx, @NotNull byte[] msg, int eTextRep ); @@ -1260,32 +1555,32 @@ public final class SQLite3Jni { } @Canonical - public static native void sqlite3_result_error_toobig( + static native void sqlite3_result_error_toobig( @NotNull sqlite3_context cx ); @Canonical - public static native void sqlite3_result_error_nomem( + static native void sqlite3_result_error_nomem( @NotNull sqlite3_context cx ); @Canonical - public static native void sqlite3_result_error_code( + static native void sqlite3_result_error_code( @NotNull sqlite3_context cx, int c ); @Canonical - public static native void sqlite3_result_null( + static native void sqlite3_result_null( @NotNull sqlite3_context cx ); @Canonical - public static native void sqlite3_result_int( + static native void sqlite3_result_int( @NotNull sqlite3_context cx, int v ); @Canonical - public static native void sqlite3_result_int64( + static native void sqlite3_result_int64( @NotNull sqlite3_context cx, long v ); @@ -1305,7 +1600,7 @@ public final class SQLite3Jni { @see #sqlite3_value_java_object @see #sqlite3_bind_java_object */ - public static native void sqlite3_result_java_object( + static native void sqlite3_result_java_object( @NotNull sqlite3_context cx, @NotNull Object o ); @@ -1370,17 +1665,17 @@ public final class SQLite3Jni { } @Canonical - public static native void sqlite3_result_value( + static native void sqlite3_result_value( @NotNull sqlite3_context cx, @NotNull sqlite3_value v ); @Canonical - public static native void sqlite3_result_zeroblob( + static native void sqlite3_result_zeroblob( @NotNull sqlite3_context cx, int n ); @Canonical - public static native int sqlite3_result_zeroblob64( + static native int sqlite3_result_zeroblob64( @NotNull sqlite3_context cx, long n ); @@ -1389,7 +1684,7 @@ public final class SQLite3Jni { unnecessary in Java. */ @Canonical - private static native void sqlite3_result_blob( + static native void sqlite3_result_blob( @NotNull sqlite3_context cx, @Nullable byte[] blob, int maxLen ); @@ -1419,7 +1714,7 @@ public final class SQLite3Jni { arguably unnecessary in Java.</p> */ @Canonical - private static native void sqlite3_result_blob64( + static native void sqlite3_result_blob64( @NotNull sqlite3_context cx, @Nullable byte[] blob, long maxLen ); @@ -1435,7 +1730,7 @@ public final class SQLite3Jni { arguably unnecessary in Java. */ @Canonical - private static native void sqlite3_result_text( + static native void sqlite3_result_text( @NotNull sqlite3_context cx, @Nullable byte[] utf8, int maxLen ); @@ -1481,7 +1776,7 @@ public final class SQLite3Jni { arguably unnecessary in Java. */ @Canonical - private static native void sqlite3_result_text64( + static native void sqlite3_result_text64( @NotNull sqlite3_context cx, @Nullable byte[] text, long maxLength, int encoding ); @@ -1509,22 +1804,29 @@ public final class SQLite3Jni { } @Canonical - public static native RollbackHookCallback sqlite3_rollback_hook( - @NotNull sqlite3 db, @Nullable RollbackHookCallback hook + static native RollbackHookCallback sqlite3_rollback_hook( + @NotNull long ptrToDb, @Nullable RollbackHookCallback hook ); @Canonical - public static native int sqlite3_set_authorizer( + public static RollbackHookCallback sqlite3_rollback_hook( + @NotNull sqlite3 db, @Nullable RollbackHookCallback hook + ){ + return sqlite3_rollback_hook(db.getNativePointer(), hook); + } + + @Canonical + static native int sqlite3_set_authorizer( @NotNull sqlite3 db, @Nullable AuthorizerCallback auth ); @Canonical - public static native void sqlite3_set_auxdata( + static native void sqlite3_set_auxdata( @NotNull sqlite3_context cx, int n, @Nullable Object data ); @Canonical - public static native void sqlite3_set_last_insert_rowid( + static native void sqlite3_set_last_insert_rowid( @NotNull sqlite3 db, long rowid ); @@ -1542,42 +1844,55 @@ public final class SQLite3Jni { public static synchronized native int sqlite3_shutdown(); @Canonical - public static native int sqlite3_sleep(int ms); + static native int sqlite3_sleep(int ms); @Canonical - public static native String sqlite3_sourceid(); + static native String sqlite3_sourceid(); @Canonical - public static native String sqlite3_sql(@NotNull sqlite3_stmt stmt); + static native String sqlite3_sql(@NotNull sqlite3_stmt stmt); @Canonical - public static native int sqlite3_status( + static native int sqlite3_status( int op, @NotNull OutputPointer.Int32 pCurrent, @NotNull OutputPointer.Int32 pHighwater, boolean reset ); @Canonical - public static native int sqlite3_status64( + 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); + static native int sqlite3_step(@NotNull sqlite3_stmt stmt); @Canonical - public static native int sqlite3_stmt_explain( - @NotNull sqlite3_stmt stmt, int op - ); + static native int sqlite3_stmt_explain(@NotNull long ptrToStmt, int op); + + @Canonical + public static int sqlite3_stmt_explain(@NotNull sqlite3_stmt stmt, int op){ + return sqlite3_stmt_explain(stmt.getNativePointer(), op); + } + + @Canonical + static native int sqlite3_stmt_isexplain(@NotNull long ptrToStmt); @Canonical - public static native int sqlite3_stmt_isexplain(@NotNull sqlite3_stmt stmt); + public static int sqlite3_stmt_isexplain(@NotNull sqlite3_stmt stmt){ + return sqlite3_stmt_isexplain(stmt.getNativePointer()); + } @Canonical - public static native boolean sqlite3_stmt_readonly(@NotNull sqlite3_stmt stmt); + static native boolean sqlite3_stmt_readonly(@NotNull long ptrToStmt); @Canonical - public static native int sqlite3_stmt_status( + public static boolean sqlite3_stmt_readonly(@NotNull sqlite3_stmt stmt){ + return sqlite3_stmt_readonly(stmt.getNativePointer()); + } + + @Canonical + static native int sqlite3_stmt_status( @NotNull sqlite3_stmt stmt, int op, boolean reset ); @@ -1593,7 +1908,7 @@ public final class SQLite3Jni { signature is the public-facing one. */ @Canonical - private static native int sqlite3_strglob( + static native int sqlite3_strglob( @NotNull byte[] glob, @NotNull byte[] nullTerminatedUtf8 ); @@ -1601,17 +1916,15 @@ public final class SQLite3Jni { public static int sqlite3_strglob( @NotNull String glob, @NotNull String txt ){ - return sqlite3_strglob( - (glob+"\0").getBytes(StandardCharsets.UTF_8), - (txt+"\0").getBytes(StandardCharsets.UTF_8) - ); + return sqlite3_strglob(nulTerminateUtf8(glob), + nulTerminateUtf8(txt)); } /** The LIKE counterpart of the private sqlite3_strglob() method. */ @Canonical - private static native int sqlite3_strlike( + static native int sqlite3_strlike( @NotNull byte[] glob, @NotNull byte[] nullTerminatedUtf8, int escChar ); @@ -1620,18 +1933,21 @@ public final class SQLite3Jni { public static int sqlite3_strlike( @NotNull String glob, @NotNull String txt, char escChar ){ - return sqlite3_strlike( - (glob+"\0").getBytes(StandardCharsets.UTF_8), - (txt+"\0").getBytes(StandardCharsets.UTF_8), - (int)escChar - ); + return sqlite3_strlike(nulTerminateUtf8(glob), + nulTerminateUtf8(txt), + (int)escChar); } @Canonical - public static native int sqlite3_system_errno(@NotNull sqlite3 db); + static native int sqlite3_system_errno(@NotNull long ptrToDb); + + @Canonical + public static int sqlite3_system_errno(@NotNull sqlite3 db){ + return sqlite3_system_errno(db.getNativePointer()); + } @Canonical - public static native int sqlite3_table_column_metadata( + static native int sqlite3_table_column_metadata( @NotNull sqlite3 db, @NotNull String zDbName, @NotNull String zTableName, @NotNull String zColumnName, @Nullable OutputPointer.String pzDataType, @@ -1670,13 +1986,23 @@ public final class SQLite3Jni { } @Canonical - public static native int sqlite3_threadsafe(); + static native int sqlite3_threadsafe(); + + @Canonical + static native int sqlite3_total_changes(@NotNull long ptrToDb); @Canonical - public static native int sqlite3_total_changes(@NotNull sqlite3 db); + public static int sqlite3_total_changes(@NotNull sqlite3 db){ + return sqlite3_total_changes(db.getNativePointer()); + } @Canonical - public static native long sqlite3_total_changes64(@NotNull sqlite3 db); + static native long sqlite3_total_changes64(@NotNull long ptrToDb); + + @Canonical + public static long sqlite3_total_changes64(@NotNull sqlite3 db){ + return sqlite3_total_changes64(db.getNativePointer()); + } /** Works like C's sqlite3_trace_v2() except that the 3rd argument to that @@ -1688,20 +2014,27 @@ public final class SQLite3Jni { mapping state fails. */ @Canonical - public static native int sqlite3_trace_v2( + static native int sqlite3_trace_v2( @NotNull sqlite3 db, int traceMask, @Nullable TraceV2Callback tracer ); @Canonical - public static native int sqlite3_txn_state( + static native int sqlite3_txn_state( @NotNull sqlite3 db, @Nullable String zSchema ); @Canonical - public static native UpdateHookCallback sqlite3_update_hook( - @NotNull sqlite3 db, @Nullable UpdateHookCallback hook + static native UpdateHookCallback sqlite3_update_hook( + @NotNull long ptrToDb, @Nullable UpdateHookCallback hook ); + @Canonical + public static UpdateHookCallback sqlite3_update_hook( + @NotNull sqlite3 db, @Nullable UpdateHookCallback hook + ){ + return sqlite3_update_hook(db.getNativePointer(), hook); + } + /* Note that: @@ -1713,33 +2046,86 @@ public final class SQLite3Jni { */ @Canonical - public static native byte[] sqlite3_value_blob(@NotNull sqlite3_value v); + static native byte[] sqlite3_value_blob(@NotNull long ptrToValue); @Canonical - public static native int sqlite3_value_bytes(@NotNull sqlite3_value v); + public static byte[] sqlite3_value_blob(@NotNull sqlite3_value v){ + return sqlite3_value_blob(v.getNativePointer()); + } @Canonical - public static native int sqlite3_value_bytes16(@NotNull sqlite3_value v); + static native int sqlite3_value_bytes(@NotNull long ptrToValue); @Canonical - public static native double sqlite3_value_double(@NotNull sqlite3_value v); + public static int sqlite3_value_bytes(@NotNull sqlite3_value v){ + return sqlite3_value_bytes(v.getNativePointer()); + } @Canonical - public static native sqlite3_value sqlite3_value_dup( - @NotNull sqlite3_value v - ); + static native int sqlite3_value_bytes16(@NotNull long ptrToValue); @Canonical - public static native int sqlite3_value_encoding(@NotNull sqlite3_value v); + public static int sqlite3_value_bytes16(@NotNull sqlite3_value v){ + return sqlite3_value_bytes16(v.getNativePointer()); + } @Canonical - public static native void sqlite3_value_free(@Nullable sqlite3_value v); + static native double sqlite3_value_double(@NotNull long ptrToValue); @Canonical - public static native int sqlite3_value_int(@NotNull sqlite3_value v); + public static double sqlite3_value_double(@NotNull sqlite3_value v){ + return sqlite3_value_double(v.getNativePointer()); + } @Canonical - public static native long sqlite3_value_int64(@NotNull sqlite3_value v); + static native sqlite3_value sqlite3_value_dup(@NotNull long ptrToValue); + + @Canonical + public static sqlite3_value sqlite3_value_dup(@NotNull sqlite3_value v){ + return sqlite3_value_dup(v.getNativePointer()); + } + + @Canonical + static native int sqlite3_value_encoding(@NotNull long ptrToValue); + + @Canonical + public static int sqlite3_value_encoding(@NotNull sqlite3_value v){ + return sqlite3_value_encoding(v.getNativePointer()); + } + + @Canonical + static native void sqlite3_value_free(@Nullable long ptrToValue); + + @Canonical + public static void sqlite3_value_free(@Nullable sqlite3_value v){ + sqlite3_value_free(v.getNativePointer()); + } + + @Canonical + static native int sqlite3_value_frombind(@NotNull long ptrToValue); + + @Canonical + public static int sqlite3_value_frombind(@NotNull sqlite3_value v){ + return sqlite3_value_frombind(v.getNativePointer()); + } + + @Canonical + static native int sqlite3_value_int(@NotNull long ptrToValue); + + @Canonical + public static int sqlite3_value_int(@NotNull sqlite3_value v){ + return sqlite3_value_int(v.getNativePointer()); + } + + @Canonical + static native long sqlite3_value_int64(@NotNull long ptrToValue); + + @Canonical + public static long sqlite3_value_int64(@NotNull sqlite3_value v){ + return sqlite3_value_int64(v.getNativePointer()); + } + + static native Object sqlite3_value_java_object(@NotNull long ptrToValue); /** If the given value was set using {@link @@ -1749,9 +2135,9 @@ public final class SQLite3Jni { <p>It is up to the caller to inspect the object to determine its type, and cast it if necessary. */ - public static native Object sqlite3_value_java_object( - @NotNull sqlite3_value v - ); + public static Object sqlite3_value_java_object(@NotNull sqlite3_value v){ + return sqlite3_value_java_object(v.getNativePointer()); + } /** A variant of sqlite3_value_java_object() which returns the @@ -1765,6 +2151,33 @@ public final class SQLite3Jni { return type.isInstance(o) ? (T)o : null; } + @Canonical + static native int sqlite3_value_nochange(@NotNull long ptrToValue); + + @Canonical + public static int sqlite3_value_nochange(@NotNull sqlite3_value v){ + return sqlite3_value_nochange(v.getNativePointer()); + } + + @Canonical + static native int sqlite3_value_numeric_type(@NotNull long ptrToValue); + + @Canonical + public static int sqlite3_value_numeric_type(@NotNull sqlite3_value v){ + return sqlite3_value_numeric_type(v.getNativePointer()); + } + + @Canonical + static native int sqlite3_value_subtype(@NotNull long ptrToValue); + + @Canonical + public static int sqlite3_value_subtype(@NotNull sqlite3_value v){ + return sqlite3_value_subtype(v.getNativePointer()); + } + + @Canonical + static native byte[] sqlite3_value_text(@NotNull long ptrToValue); + /** Functions identially to the C API, and this note is just to stress that the returned bytes are encoded as UTF-8. It returns @@ -1772,25 +2185,25 @@ public final class SQLite3Jni { or on allocation error. */ @Canonical - public static native byte[] sqlite3_value_text(@NotNull sqlite3_value v); - - @Canonical - public static native String sqlite3_value_text16(@NotNull sqlite3_value v); - - @Canonical - public static native int sqlite3_value_type(@NotNull sqlite3_value v); + public static byte[] sqlite3_value_text(@NotNull sqlite3_value v){ + return sqlite3_value_text(v.getNativePointer()); + } @Canonical - public static native int sqlite3_value_numeric_type(@NotNull sqlite3_value v); + static native String sqlite3_value_text16(@NotNull long ptrToValue); @Canonical - public static native int sqlite3_value_nochange(@NotNull sqlite3_value v); + public static String sqlite3_value_text16(@NotNull sqlite3_value v){ + return sqlite3_value_text16(v.getNativePointer()); + } @Canonical - public static native int sqlite3_value_frombind(@NotNull sqlite3_value v); + static native int sqlite3_value_type(@NotNull long ptrToValue); @Canonical - public static native int sqlite3_value_subtype(@NotNull sqlite3_value v); + public static int sqlite3_value_type(@NotNull sqlite3_value v){ + return sqlite3_value_type(v.getNativePointer()); + } /** This is NOT part of the public API. It exists solely as a place @@ -1798,7 +2211,7 @@ public final class SQLite3Jni { It has no stable interface. It may go way or change behavior at any time. */ - public static native void sqlite3_jni_internal_details(); + static native void sqlite3_jni_internal_details(); ////////////////////////////////////////////////////////////////////// // SQLITE_... constants follow... diff --git a/ext/jni/src/org/sqlite/jni/Tester1.java b/ext/jni/src/org/sqlite/jni/Tester1.java index 37125744f..9d40eb9ed 100644 --- a/ext/jni/src/org/sqlite/jni/Tester1.java +++ b/ext/jni/src/org/sqlite/jni/Tester1.java @@ -1283,7 +1283,7 @@ public class Tester1 implements Runnable { } Exception err = null; try { - Class t = Class.forName("org.sqlite.jni.fts5.TesterFts5"); + Class t = Class.forName("org.sqlite.jni.TesterFts5"); java.lang.reflect.Constructor ctor = t.getConstructor(); ctor.setAccessible(true); final long timeStart = System.currentTimeMillis(); @@ -1515,35 +1515,34 @@ public class Tester1 implements Runnable { } private void testBackup(){ - final sqlite3 db1 = createNewDb(); - final sqlite3 db2 = createNewDb(); - - execSql(db1, new String[]{ - "pragma page_size=512; VACUUM;", - "create table t(a);", - "insert into t(a) values(1),(2),(3);" - }); - affirm( null==sqlite3_backup_init(db1,"main",db1,"main") ); - final sqlite3_backup b = sqlite3_backup_init(db2,"main",db1,"main"); - affirm( null!=b ); - affirm( b.getNativePointer()!=0 ); - int rc; - while( SQLITE_DONE!=(rc = sqlite3_backup_step(b, 1)) ){ - affirm( 0==rc ); + final sqlite3 dbDest = createNewDb(); + + try (sqlite3 dbSrc = createNewDb()) { + execSql(dbSrc, new String[]{ + "pragma page_size=512; VACUUM;", + "create table t(a);", + "insert into t(a) values(1),(2),(3);" + }); + affirm( null==sqlite3_backup_init(dbSrc,"main",dbSrc,"main") ); + try (sqlite3_backup b = sqlite3_backup_init(dbDest,"main",dbSrc,"main")) { + affirm( null!=b ); + affirm( b.getNativePointer()!=0 ); + int rc; + while( SQLITE_DONE!=(rc = sqlite3_backup_step(b, 1)) ){ + affirm( 0==rc ); + } + affirm( sqlite3_backup_pagecount(b) > 0 ); + rc = sqlite3_backup_finish(b); + affirm( 0==rc ); + affirm( b.getNativePointer()==0 ); + } } - affirm( sqlite3_backup_pagecount(b) > 0 ); - rc = sqlite3_backup_finish(b); - affirm( 0==rc ); - affirm( b.getNativePointer()==0 ); - - sqlite3_close_v2(db1); - - final sqlite3_stmt stmt = prepare(db2,"SELECT sum(a) from t"); - sqlite3_step(stmt); - affirm( sqlite3_column_int(stmt,0) == 6 ); - sqlite3_finalize(stmt); - sqlite3_close_v2(db2); + try (sqlite3_stmt stmt = prepare(dbDest,"SELECT sum(a) from t")) { + sqlite3_step(stmt); + affirm( sqlite3_column_int(stmt,0) == 6 ); + } + sqlite3_close_v2(dbDest); } private void testRandomness(){ diff --git a/ext/jni/src/org/sqlite/jni/fts5/TesterFts5.java b/ext/jni/src/org/sqlite/jni/TesterFts5.java index d65b7b7a5..8577ee46e 100644 --- a/ext/jni/src/org/sqlite/jni/fts5/TesterFts5.java +++ b/ext/jni/src/org/sqlite/jni/TesterFts5.java @@ -11,10 +11,11 @@ ************************************************************************* ** This file contains a set of tests for the sqlite3 JNI bindings. */ -package org.sqlite.jni.fts5; +package org.sqlite.jni; import static org.sqlite.jni.SQLite3Jni.*; import static org.sqlite.jni.Tester1.*; import org.sqlite.jni.*; +import org.sqlite.jni.fts5.*; import java.util.*; diff --git a/ext/jni/src/org/sqlite/jni/annotation/Canonical.java b/ext/jni/src/org/sqlite/jni/annotation/Canonical.java index fdb157335..ebad0a44d 100644 --- a/ext/jni/src/org/sqlite/jni/annotation/Canonical.java +++ b/ext/jni/src/org/sqlite/jni/annotation/Canonical.java @@ -1,3 +1,16 @@ +/* +** 2023-09-27 +** +** 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 houses the Canonical annotaion for the sqlite3 C API. +*/ package org.sqlite.jni.annotation; /** diff --git a/ext/jni/src/org/sqlite/jni/annotation/NotNull.java b/ext/jni/src/org/sqlite/jni/annotation/NotNull.java index 49003358d..3b4c1c7af 100644 --- a/ext/jni/src/org/sqlite/jni/annotation/NotNull.java +++ b/ext/jni/src/org/sqlite/jni/annotation/NotNull.java @@ -1,3 +1,16 @@ +/* +** 2023-09-27 +** +** 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 houses the NotNull annotaion for the sqlite3 C API. +*/ package org.sqlite.jni.annotation; /** @@ -20,6 +33,11 @@ package org.sqlite.jni.annotation; any parameter marked with this annoation specifically invokes undefined behavior.</p> + <p>Passing 0 (i.e. C NULL) or a negative value for any long-type + parameter marked with this annoation specifically invokes undefined + behavior. Such values are treated as C pointers in the JNI + layer.</p> + <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 @@ -29,10 +47,11 @@ package org.sqlite.jni.annotation; programmatically ensure that NotNull is conformed to in client code.</p> - <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 - annotated functions. It is not part of the public API and - client-level code must not rely on it.</p> + <p>This annotation is solely for the use by the classes in the + org.sqlite package and subpackages, but is made public so that + javadoc will link to it from the annotated functions. It is not + part of the public API and client-level code must not rely on + it.</p> */ @java.lang.annotation.Documented @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE) diff --git a/ext/jni/src/org/sqlite/jni/annotation/Nullable.java b/ext/jni/src/org/sqlite/jni/annotation/Nullable.java index 7a011e33b..ddc8502d6 100644 --- a/ext/jni/src/org/sqlite/jni/annotation/Nullable.java +++ b/ext/jni/src/org/sqlite/jni/annotation/Nullable.java @@ -1,3 +1,16 @@ +/* +** 2023-09-27 +** +** 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 houses the Nullable annotaion for the sqlite3 C API. +*/ package org.sqlite.jni.annotation; /** diff --git a/ext/jni/src/org/sqlite/jni/annotation/package-info.java b/ext/jni/src/org/sqlite/jni/annotation/package-info.java index 50db2a32b..20ac7a301 100644 --- a/ext/jni/src/org/sqlite/jni/annotation/package-info.java +++ b/ext/jni/src/org/sqlite/jni/annotation/package-info.java @@ -1,4 +1,17 @@ +/* +** 2023-09-27 +** +** 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 package houses annotations specific a JNI binding to the SQLite3 C API. + This package houses annotations specific to the JNI bindings of the + SQLite3 C API. */ package org.sqlite.jni.annotation; diff --git a/ext/jni/src/org/sqlite/jni/sqlite3.java b/ext/jni/src/org/sqlite/jni/sqlite3.java index 3f15c4580..ba515b3f4 100644 --- a/ext/jni/src/org/sqlite/jni/sqlite3.java +++ b/ext/jni/src/org/sqlite/jni/sqlite3.java @@ -39,10 +39,10 @@ public final class sqlite3 extends NativePointerHolder<sqlite3> @Override protected void finalize(){ //System.out.println(this+".finalize()"); - SQLite3Jni.sqlite3_close_v2(this); + SQLite3Jni.sqlite3_close_v2(this.clearNativePointer()); } @Override public void close(){ - SQLite3Jni.sqlite3_close_v2(this); + SQLite3Jni.sqlite3_close_v2(this.clearNativePointer()); } } diff --git a/ext/jni/src/org/sqlite/jni/sqlite3_backup.java b/ext/jni/src/org/sqlite/jni/sqlite3_backup.java index d8ba78aec..1e12e65cd 100644 --- a/ext/jni/src/org/sqlite/jni/sqlite3_backup.java +++ b/ext/jni/src/org/sqlite/jni/sqlite3_backup.java @@ -19,7 +19,13 @@ package org.sqlite.jni; simply provide a type-safe way to communicate it between Java and C via JNI. */ -public final class sqlite3_backup extends NativePointerHolder<sqlite3_backup> { +public final class sqlite3_backup extends NativePointerHolder<sqlite3_backup> + implements AutoCloseable { // Only invoked from JNI. private sqlite3_backup(){} + + @Override public void close(){ + SQLite3Jni.sqlite3_backup_finish(this); + } + } diff --git a/ext/jni/src/org/sqlite/jni/sqlite3_blob.java b/ext/jni/src/org/sqlite/jni/sqlite3_blob.java index e51213025..46c3c9029 100644 --- a/ext/jni/src/org/sqlite/jni/sqlite3_blob.java +++ b/ext/jni/src/org/sqlite/jni/sqlite3_blob.java @@ -19,7 +19,13 @@ package org.sqlite.jni; simply provide a type-safe way to communicate it between Java and C via JNI. */ -public final class sqlite3_blob extends NativePointerHolder<sqlite3_blob> { +public final class sqlite3_blob extends NativePointerHolder<sqlite3_blob> + implements AutoCloseable { // Only invoked from JNI. private sqlite3_blob(){} + + @Override public void close(){ + SQLite3Jni.sqlite3_blob_close(this.clearNativePointer()); + } + } diff --git a/ext/jni/src/org/sqlite/jni/sqlite3_stmt.java b/ext/jni/src/org/sqlite/jni/sqlite3_stmt.java index 567a20cfa..d918d380c 100644 --- a/ext/jni/src/org/sqlite/jni/sqlite3_stmt.java +++ b/ext/jni/src/org/sqlite/jni/sqlite3_stmt.java @@ -26,10 +26,10 @@ public final class sqlite3_stmt extends NativePointerHolder<sqlite3_stmt> //For as-yet-unknown reasons, this triggers a JVM crash. //@Override protected void finalize(){ - // SQLite3Jni.sqlite3_finalize(this); + // SQLite3Jni.sqlite3_finalize(this.clearNativePointer()); //} @Override public void close(){ - SQLite3Jni.sqlite3_finalize(this); + SQLite3Jni.sqlite3_finalize(this.clearNativePointer()); } } diff --git a/ext/jni/src/org/sqlite/jni/tester/test-script-interpreter.md b/ext/jni/src/org/sqlite/jni/test-script-interpreter.md index a51d64d10..a51d64d10 100644 --- a/ext/jni/src/org/sqlite/jni/tester/test-script-interpreter.md +++ b/ext/jni/src/org/sqlite/jni/test-script-interpreter.md |