koffi 2.2.0 → 2.2.2-beta.1

package/src/koffi/src/ffi.cc

@@ -44,6 +44,8 @@ namespace RG {
 const int TypeInfoMarker = 0xDEADBEEF;
 const int CastMarker = 0xDEADBEEF;
 
+static RG_THREAD_LOCAL CallData *exec_call;
+
 static bool ChangeSize(const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
 {
     Napi::Env env = value.Env();
@@ -972,16 +974,16 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
                 Napi::Object members = Napi::Object::New(env);
 
                 for (const RecordMember &member: type->members) {
-                    Napi::Object info = Napi::Object::New(env);
+                    Napi::Object obj = Napi::Object::New(env);
 
                     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)member.type);
                     SetValueTag(instance, external, &TypeInfoMarker);
 
-                    info.Set("name", member.name);
-                    info.Set("type", external);
-                    info.Set("offset", member.offset);
+                    obj.Set("name", member.name);
+                    obj.Set("type", external);
+                    obj.Set("offset", member.offset);
 
-                    members.Set(member.name, info);
+                    members.Set(member.name, obj);
                 }
 
                 defn.Set("members", members);
@@ -1057,7 +1059,10 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     }
 
     InstanceMemory *mem = instance->memories[0];
-    CallData call(env, instance, func, mem);
+    CallData call(env, instance, func, mem, false);
+
+    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+    exec_call = &call;
 
     if (!RG_UNLIKELY(call.Prepare(info)))
         return env.Null();
@@ -1065,7 +1070,14 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     if (instance->debug) {
         call.DumpForward();
     }
-    call.Execute();
+
+    // Execute call
+    {
+        RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+        exec_call = &call;
+
+        call.Execute();
+    }
 
     return call.Complete();
 }
@@ -1124,7 +1136,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         return env.Null();
 
     InstanceMemory *mem = instance->memories[0];
-    CallData call(env, instance, &func, mem);
+    CallData call(env, instance, &func, mem, false);
 
     if (!RG_UNLIKELY(call.Prepare(info)))
         return env.Null();
@@ -1132,7 +1144,14 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     if (instance->debug) {
         call.DumpForward();
     }
-    call.Execute();
+
+    // Execute call
+    {
+        RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+        exec_call = &call;
+
+        call.Execute();
+    }
 
     return call.Complete();
 }
@@ -1148,7 +1167,7 @@ public:
     AsyncCall(Napi::Env env, InstanceData *instance, const FunctionInfo *func,
               InstanceMemory *mem, Napi::Function &callback)
         : Napi::AsyncWorker(callback), env(env), func(func->Ref()),
-          call(env, instance, func, mem) {}
+          call(env, instance, func, mem, true) {}
     ~AsyncCall() { func->Unref(); }
 
     bool Prepare(const Napi::CallbackInfo &info) {
@@ -1170,6 +1189,9 @@ public:
 void AsyncCall::Execute()
 {
     if (prepared) {
+        RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+        exec_call = &call;
+
         call.Execute();
     }
 }
@@ -1673,6 +1695,10 @@ InstanceData::~InstanceData()
     for (InstanceMemory *mem: memories) {
         delete mem;
     }
+
+    if (broker) {
+        napi_release_threadsafe_function(broker, napi_tsfn_abort);
+    }
 }
 
 static Napi::Value CastValue(const Napi::CallbackInfo &info)
@@ -1828,6 +1854,30 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     return env.Null();
 }
 
+extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+{
+    exec_call->RelaySafe(idx, own_sp, caller_sp, out_reg);
+}
+
+static InstanceData *CreateInstance(Napi::Env env)
+{
+    InstanceData *instance = new InstanceData();
+    RG_DEFER_N(err_guard) { delete instance; };
+
+    Napi::String resource_name = Napi::String::New(env, "Koffi Async Callback Broker");
+
+    if (napi_create_threadsafe_function(env, nullptr, nullptr, resource_name,
+                                        0, 1, nullptr, nullptr, nullptr,
+                                        CallData::RelayAsync, &instance->broker) != napi_ok) {
+        LogError("Failed to create async callback broker");
+        return nullptr;
+    }
+    napi_unref_threadsafe_function(env, instance->broker);
+
+    err_guard.Disable();
+    return instance;
+}
+
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {
@@ -1906,7 +1956,9 @@ static void InitInternal(v8::Local<v8::Object> target, v8::Local<v8::Value>,
         delete env_napi;
     }, env_napi);
 
-    InstanceData *instance = new InstanceData();
+    InstanceData *instance = CreateInstance(env_cxx);
+    RG_CRITICAL(instance, "Failed to initialize Koffi");
+
     env_cxx.SetInstanceData(instance);
 
     instance->debug = GetDebugFlag("DUMP_CALLS");
@@ -1922,7 +1974,9 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 {
     using namespace RG;
 
-    InstanceData *instance = new InstanceData();
+    InstanceData *instance = CreateInstance(env);
+    RG_CRITICAL(instance, "Failed to initialize Koffi");
+
     env.SetInstanceData(instance);
 
     instance->debug = GetDebugFlag("DUMP_CALLS");

package/src/koffi/src/ffi.hh

@@ -263,6 +263,8 @@ struct InstanceData {
     int16_t temp_trampolines = 0;
     uint32_t registered_trampolines = 0;
 
+    napi_threadsafe_function broker = nullptr;
+
     BlockAllocator str_alloc;
 
     Size sync_stack_size = DefaultSyncStackSize;

package/src/koffi/src/index.js

@@ -18,6 +18,10 @@
 const util = require('util');
 
 let filename = __dirname + '/../build/koffi.node';
-module.exports = require(filename);
 
-module.exports.handle = util.deprecate(module.exports.opaque, 'The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead', 'KOFFI001');
+module.exports = {
+    ...require(filename),
+
+    // Deprecated functions
+    handle: util.deprecate(module.exports.opaque, 'The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead', 'KOFFI001');
+};

package/src/koffi/test/CMakeLists.txt

@@ -100,7 +100,7 @@ endif()
 
 # ---- SQLite ----
 
-add_library(sqlite3 SHARED ../../../vendor/sqlite3mc/sqlite3.c)
+add_library(sqlite3 SHARED ../../../vendor/sqlite3/sqlite3.c)
 set_target_properties(sqlite3 PROPERTIES PREFIX "")
 
 if(WIN32)

package/src/koffi/test/async.js

@@ -28,6 +28,8 @@ const PackedBFG = koffi.pack('PackedBFG', {
     })
 });
 
+const CharCallback = koffi.callback('int CharCallback(int idx, char c)');
+
 main();
 
 async function main() {
@@ -46,6 +48,7 @@ async function test() {
 
     const ConcatenateToInt1 = lib.func('ConcatenateToInt1', 'int64_t', Array(12).fill('int8_t'));
     const MakePackedBFG = lib.func('PackedBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
+    const CallMeChar = lib.func('int CallMeChar(CharCallback *func)');
 
     let promises = [];
 

package/src/koffi/test/callbacks.js

@@ -15,6 +15,7 @@
 
 const koffi = require('./build/koffi.node');
 const assert = require('assert');
+const util = require('util');
 
 const BFG = koffi.struct('BFG', {
     a: 'int8_t',
@@ -41,6 +42,7 @@ const ApplyCallback = koffi.callback('int __stdcall ApplyCallback(int a, int b,
 const IntCallback = koffi.callback('int IntCallback(int x)');
 const VectorCallback = koffi.callback('int VectorCallback(int len, Vec2 *vec)');
 const SortCallback = koffi.callback('int SortCallback(const void *ptr1, const void *ptr2)');
+const CharCallback = koffi.callback('int CharCallback(int idx, char c)');
 
 const StructCallbacks = koffi.struct('StructCallbacks', {
     first: koffi.pointer(IntCallback),
@@ -75,6 +77,8 @@ async function test() {
     const CallCallback = lib.func('int CallCallback(int x)');
     const MakeVectors = lib.func('int MakeVectors(int len, VectorCallback *func)');
     const CallQSort = lib.func('void CallQSort(_Inout_ void *base, size_t nmemb, size_t size, SortCallback *cb)');
+    const CallMeChar = lib.func('int CallMeChar(CharCallback *func)');
+    const GetMinusOne1 = lib.func('int8_t GetMinusOne1(void)');
 
     // Simple test similar to README example
     {
@@ -230,4 +234,30 @@ async function test() {
 
         assert.deepEqual(array, ['123', 'bar', 'foo', 'foobar']);
     }
+
+    // Make sure thread local CallData is restored after nested call inside callback
+    // Regression test for issue #15
+    {
+        let chars = [97, 98];
+
+        let cb = koffi.register((idx, c) => {
+            assert.equal(GetMinusOne1(), -1);
+            assert.equal(c, chars[idx]);
+
+            return c;
+        }, 'CharCallback *');
+
+        let ret = CallMeChar(cb);
+        assert.equal(ret, 97 + 98);
+    }
+
+    // Test callback inside async function
+    {
+        let chars = [97, 98];
+
+        let cb = koffi.register((idx, c) => (idx + 1) * c, 'CharCallback *');
+        let ret = await util.promisify(CallMeChar.async)(cb);
+
+        assert.equal(ret, 97 + 2 * 98);
+    }
 }

package/src/koffi/test/misc.c

@@ -169,6 +169,7 @@ typedef struct Vec2 {
 
 typedef int VectorCallback(int len, Vec2 *vec);
 typedef int SortCallback(const void *ptr1, const void *ptr2);
+typedef int CharCallback(int idx, char c);
 
 EXPORT int8_t GetMinusOne1(void)
 {
@@ -776,3 +777,13 @@ EXPORT void CallQSort(void *base, size_t nmemb, size_t size, SortCallback *cb)
 {
     qsort(base, nmemb, size, cb);
 }
+
+EXPORT int CallMeChar(CharCallback *func)
+{
+    int ret = 0;
+
+    ret += func(0, 'a');
+    ret += func(1, 'b');
+
+    return ret;
+}

package/vendor/{sqlite3mc → sqlite3}/sqlite3.c

@@ -1,6 +1,6 @@
 /******************************************************************************
 ** This file is an amalgamation of many separate C source files from SQLite
-** version 3.40.0.  By combining all the individual C code files into this
+** version 3.40.1.  By combining all the individual C code files into this
 ** single large file, the entire code can be compiled as a single translation
 ** unit.  This allows many compilers to do optimizations that would not be
 ** possible if the files were compiled separately.  Performance improvements
@@ -452,9 +452,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.40.0"
-#define SQLITE_VERSION_NUMBER 3040000
-#define SQLITE_SOURCE_ID      "2022-11-16 12:10:08 89c459e766ea7e9165d0beeb124708b955a4950d0f4792f457465d71b158d318"
+#define SQLITE_VERSION        "3.40.1"
+#define SQLITE_VERSION_NUMBER 3040001
+#define SQLITE_SOURCE_ID      "2022-12-28 14:03:47 df5c253c0b3dd24916e4ec7cf77d3db5294cc9fd45ae7b9c5e82ad8197f38a24"
 
 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -1498,6 +1498,12 @@ struct sqlite3_io_methods {
 **
 ** <li>[[SQLITE_FCNTL_CKSM_FILE]]
 ** Used by the cksmvfs VFS module only.
+**
+** <li>[[SQLITE_FCNTL_RESET_CACHE]]
+** If there is currently no transaction open on the database, and the
+** database is not a temp db, then this file-control purges the contents
+** of the in-memory page cache. If there is an open transaction, or if
+** the db is a temp-db, it is a no-op, not an error.
 ** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1
@@ -1540,6 +1546,7 @@ struct sqlite3_io_methods {
 #define SQLITE_FCNTL_CKPT_START             39
 #define SQLITE_FCNTL_EXTERNAL_READER        40
 #define SQLITE_FCNTL_CKSM_FILE              41
+#define SQLITE_FCNTL_RESET_CACHE            42
 
 /* deprecated names */
 #define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE
@@ -15714,6 +15721,8 @@ SQLITE_PRIVATE   int sqlite3BtreeCheckpoint(Btree*, int, int *, int *);
 
 SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor*, BtCursor*, i64);
 
+SQLITE_PRIVATE void sqlite3BtreeClearCache(Btree*);
+
 /*
 ** If we are not using shared cache, then there is no need to
 ** use mutexes to access the BtShared structures.  So make the
@@ -27290,9 +27299,13 @@ static int memsys5Roundup(int n){
     if( n<=mem5.szAtom ) return mem5.szAtom;
     return mem5.szAtom*2;
   }
-  if( n>0x40000000 ) return 0;
+  if( n>0x10000000 ){
+    if( n>0x40000000 ) return 0;
+    if( n>0x20000000 ) return 0x40000000;
+    return 0x20000000;
+  }
   for(iFullSz=mem5.szAtom*8; iFullSz<n; iFullSz *= 4);
-  if( (iFullSz/2)>=n ) return iFullSz/2;
+  if( (iFullSz/2)>=(i64)n ) return iFullSz/2;
   return iFullSz;
 }
 
@@ -37350,6 +37363,9 @@ static int robust_open(const char *z, int f, mode_t m){
       break;
     }
     if( fd>=SQLITE_MINIMUM_FILE_DESCRIPTOR ) break;
+    if( (f & (O_EXCL|O_CREAT))==(O_EXCL|O_CREAT) ){
+      (void)osUnlink(z);
+    }
     osClose(fd);
     sqlite3_log(SQLITE_WARNING,
                 "attempt to open \"%s\" as file descriptor %d", z, fd);
@@ -51083,6 +51099,7 @@ static int memdbTruncate(sqlite3_file*, sqlite3_int64 size);
 static int memdbSync(sqlite3_file*, int flags);
 static int memdbFileSize(sqlite3_file*, sqlite3_int64 *pSize);
 static int memdbLock(sqlite3_file*, int);
+static int memdbUnlock(sqlite3_file*, int);
 /* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */
 static int memdbFileControl(sqlite3_file*, int op, void *pArg);
 /* static int memdbSectorSize(sqlite3_file*); // not used */
@@ -51141,7 +51158,7 @@ static const sqlite3_io_methods memdb_io_methods = {
   memdbSync,                       /* xSync */
   memdbFileSize,                   /* xFileSize */
   memdbLock,                       /* xLock */
-  memdbLock,                       /* xUnlock - same as xLock in this case */
+  memdbUnlock,                     /* xUnlock */
   0, /* memdbCheckReservedLock, */ /* xCheckReservedLock */
   memdbFileControl,                /* xFileControl */
   0, /* memdbSectorSize,*/         /* xSectorSize */
@@ -51342,39 +51359,81 @@ static int memdbLock(sqlite3_file *pFile, int eLock){
   MemFile *pThis = (MemFile*)pFile;
   MemStore *p = pThis->pStore;
   int rc = SQLITE_OK;
-  if( eLock==pThis->eLock ) return SQLITE_OK;
+  if( eLock<=pThis->eLock ) return SQLITE_OK;
   memdbEnter(p);
-  if( eLock>SQLITE_LOCK_SHARED ){
-    if( p->mFlags & SQLITE_DESERIALIZE_READONLY ){
-      rc = SQLITE_READONLY;
-    }else if( pThis->eLock<=SQLITE_LOCK_SHARED ){
-      if( p->nWrLock ){
-        rc = SQLITE_BUSY;
-      }else{
-        p->nWrLock = 1;
+
+  assert( p->nWrLock==0 || p->nWrLock==1 );
+  assert( pThis->eLock<=SQLITE_LOCK_SHARED || p->nWrLock==1 );
+  assert( pThis->eLock==SQLITE_LOCK_NONE || p->nRdLock>=1 );
+
+  if( eLock>SQLITE_LOCK_SHARED && (p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
+    rc = SQLITE_READONLY;
+  }else{
+    switch( eLock ){
+      case SQLITE_LOCK_SHARED: {
+        assert( pThis->eLock==SQLITE_LOCK_NONE );
+        if( p->nWrLock>0 ){
+          rc = SQLITE_BUSY;
+        }else{
+          p->nRdLock++;
+        }
+        break;
+      };
+
+      case SQLITE_LOCK_RESERVED:
+      case SQLITE_LOCK_PENDING: {
+        assert( pThis->eLock>=SQLITE_LOCK_SHARED );
+        if( ALWAYS(pThis->eLock==SQLITE_LOCK_SHARED) ){
+          if( p->nWrLock>0 ){
+            rc = SQLITE_BUSY;
+          }else{
+            p->nWrLock = 1;
+          }
+        }
+        break;
+      }
+
+      default: {
+        assert(  eLock==SQLITE_LOCK_EXCLUSIVE );
+        assert( pThis->eLock>=SQLITE_LOCK_SHARED );
+        if( p->nRdLock>1 ){
+          rc = SQLITE_BUSY;
+        }else if( pThis->eLock==SQLITE_LOCK_SHARED ){
+          p->nWrLock = 1;
+        }
+        break;
       }
     }
-  }else if( eLock==SQLITE_LOCK_SHARED ){
-    if( pThis->eLock > SQLITE_LOCK_SHARED ){
-      assert( p->nWrLock==1 );
-      p->nWrLock = 0;
-    }else if( p->nWrLock ){
-      rc = SQLITE_BUSY;
-    }else{
-      p->nRdLock++;
+  }
+  if( rc==SQLITE_OK ) pThis->eLock = eLock;
+  memdbLeave(p);
+  return rc;
+}
+
+/*
+** Unlock an memdb-file.
+*/
+static int memdbUnlock(sqlite3_file *pFile, int eLock){
+  MemFile *pThis = (MemFile*)pFile;
+  MemStore *p = pThis->pStore;
+  if( eLock>=pThis->eLock ) return SQLITE_OK;
+  memdbEnter(p);
+
+  assert( eLock==SQLITE_LOCK_SHARED || eLock==SQLITE_LOCK_NONE );
+  if( eLock==SQLITE_LOCK_SHARED ){
+    if( ALWAYS(pThis->eLock>SQLITE_LOCK_SHARED) ){
+      p->nWrLock--;
     }
   }else{
-    assert( eLock==SQLITE_LOCK_NONE );
     if( pThis->eLock>SQLITE_LOCK_SHARED ){
-      assert( p->nWrLock==1 );
-      p->nWrLock = 0;
+      p->nWrLock--;
     }
-    assert( p->nRdLock>0 );
     p->nRdLock--;
   }
-  if( rc==SQLITE_OK ) pThis->eLock = eLock;
+
+  pThis->eLock = eLock;
   memdbLeave(p);
-  return rc;
+  return SQLITE_OK;
 }
 
 #if 0
@@ -51484,7 +51543,7 @@ static int memdbOpen(
 
   memset(pFile, 0, sizeof(*pFile));
   szName = sqlite3Strlen30(zName);
-  if( szName>1 && zName[0]=='/' ){
+  if( szName>1 && (zName[0]=='/' || zName[0]=='\\') ){
     int i;
 #ifndef SQLITE_MUTEX_OMIT
     sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
@@ -51831,6 +51890,13 @@ end_deserialize:
   return rc;
 }
 
+/*
+** Return true if the VFS is the memvfs.
+*/
+SQLITE_PRIVATE int sqlite3IsMemdb(const sqlite3_vfs *pVfs){
+  return pVfs==&memdb_vfs;
+}
+
 /*
 ** This routine is called when the extension is loaded.
 ** Register the new VFS.
@@ -79159,6 +79225,17 @@ SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *p){
 */
 SQLITE_PRIVATE int sqlite3HeaderSizeBtree(void){ return ROUND8(sizeof(MemPage)); }
 
+/*
+** If no transaction is active and the database is not a temp-db, clear
+** the in-memory pager cache.
+*/
+SQLITE_PRIVATE void sqlite3BtreeClearCache(Btree *p){
+  BtShared *pBt = p->pBt;
+  if( pBt->inTransaction==TRANS_NONE ){
+    sqlite3PagerClearCache(pBt->pPager);
+  }
+}
+
 #if !defined(SQLITE_OMIT_SHARED_CACHE)
 /*
 ** Return true if the Btree passed as the only argument is sharable.
@@ -83398,7 +83475,7 @@ SQLITE_PRIVATE void sqlite3VdbeAppendP4(Vdbe *p, void *pP4, int n){
   if( p->db->mallocFailed ){
     freeP4(p->db, n, pP4);
   }else{
-    assert( pP4!=0 );
+    assert( pP4!=0 || n==P4_DYNAMIC );
     assert( p->nOp>0 );
     pOp = &p->aOp[p->nOp-1];
     assert( pOp->p4type==P4_NOTUSED );
@@ -132310,7 +132387,7 @@ static const sqlite3_api_routines sqlite3Apis = {
 #endif
   sqlite3_db_name,
   /* Version 3.40.0 and later */
-  sqlite3_value_type
+  sqlite3_value_encoding
 };
 
 /* True if x is the directory separator character
@@ -145451,7 +145528,7 @@ SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
     if( pTrig->pTabSchema==pTab->pSchema
      && pTrig->table
      && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
-     && pTrig->pTabSchema!=pTmpSchema
+     && (pTrig->pTabSchema!=pTmpSchema || pTrig->bReturning)
     ){
       pTrig->pNext = pList;
       pList = pTrig;
@@ -155635,7 +155712,7 @@ SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo *pWInfo){
 ** block sorting is required.
 */
 SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo *pWInfo){
-  return pWInfo->nOBSat;
+  return pWInfo->nOBSat<0 ? 0 : pWInfo->nOBSat;
 }
 
 /*
@@ -174543,7 +174620,7 @@ SQLITE_API int sqlite3_overload_function(
   rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
   sqlite3_mutex_leave(db->mutex);
   if( rc ) return SQLITE_OK;
-  zCopy = sqlite3_mprintf(zName);
+  zCopy = sqlite3_mprintf("%s", zName);
   if( zCopy==0 ) return SQLITE_NOMEM;
   return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8,
                            zCopy, sqlite3InvalidFunction, 0, 0, sqlite3_free);
@@ -176375,6 +176452,9 @@ SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, vo
         sqlite3BtreeSetPageSize(pBtree, 0, iNew, 0);
       }
       rc = SQLITE_OK;
+    }else if( op==SQLITE_FCNTL_RESET_CACHE ){
+      sqlite3BtreeClearCache(pBtree);
+      rc = SQLITE_OK;
     }else{
       int nSave = db->busyHandler.nBusy;
       rc = sqlite3OsFileControl(fd, op, pArg);
@@ -217790,6 +217870,22 @@ static int sessionChangesetNextOne(
       if( p->op==SQLITE_INSERT ) p->op = SQLITE_DELETE;
       else if( p->op==SQLITE_DELETE ) p->op = SQLITE_INSERT;
     }
+
+    /* If this is an UPDATE that is part of a changeset, then check that
+    ** there are no fields in the old.* record that are not (a) PK fields,
+    ** or (b) also present in the new.* record.
+    **
+    ** Such records are technically corrupt, but the rebaser was at one
+    ** point generating them. Under most circumstances this is benign, but
+    ** can cause spurious SQLITE_RANGE errors when applying the changeset. */
+    if( p->bPatchset==0 && p->op==SQLITE_UPDATE){
+      for(i=0; i<p->nCol; i++){
+        if( p->abPK[i]==0 && p->apValue[i+p->nCol]==0 ){
+          sqlite3ValueFree(p->apValue[i]);
+          p->apValue[i] = 0;
+        }
+      }
+    }
   }
 
   return SQLITE_ROW;
@@ -219986,7 +220082,7 @@ static void sessionAppendPartialUpdate(
         if( !pIter->abPK[i] && a1[0] ) bData = 1;
         memcpy(pOut, a1, n1);
         pOut += n1;
-      }else if( a2[0]!=0xFF ){
+      }else if( a2[0]!=0xFF && a1[0] ){
         bData = 1;
         memcpy(pOut, a2, n2);
         pOut += n2;
@@ -236016,7 +236112,7 @@ static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){
       break;
 
     case FTS5_SYNC:
-      assert( p->ts.eState==1 );
+      assert( p->ts.eState==1 || p->ts.eState==2 );
       p->ts.eState = 2;
       break;
 
@@ -236031,21 +236127,21 @@ static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){
       break;
 
     case FTS5_SAVEPOINT:
-      assert( p->ts.eState==1 );
+      assert( p->ts.eState>=1 );
       assert( iSavepoint>=0 );
       assert( iSavepoint>=p->ts.iSavepoint );
       p->ts.iSavepoint = iSavepoint;
       break;
 
     case FTS5_RELEASE:
-      assert( p->ts.eState==1 );
+      assert( p->ts.eState>=1 );
       assert( iSavepoint>=0 );
       assert( iSavepoint<=p->ts.iSavepoint );
       p->ts.iSavepoint = iSavepoint-1;
       break;
 
     case FTS5_ROLLBACKTO:
-      assert( p->ts.eState==1 );
+      assert( p->ts.eState>=1 );
       assert( iSavepoint>=-1 );
       /* The following assert() can fail if another vtab strikes an error
       ** within an xSavepoint() call then SQLite calls xRollbackTo() - without
@@ -237381,7 +237477,7 @@ static int fts5UpdateMethod(
   int rc = SQLITE_OK;             /* Return code */
 
   /* A transaction must be open when this is called. */
-  assert( pTab->ts.eState==1 );
+  assert( pTab->ts.eState==1 || pTab->ts.eState==2 );
 
   assert( pVtab->zErrMsg==0 );
   assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
@@ -238549,7 +238645,7 @@ static void fts5SourceIdFunc(
 ){
   assert( nArg==0 );
   UNUSED_PARAM2(nArg, apUnused);
-  sqlite3_result_text(pCtx, "fts5: 2022-11-16 12:10:08 89c459e766ea7e9165d0beeb124708b955a4950d0f4792f457465d71b158d318", -1, SQLITE_TRANSIENT);
+  sqlite3_result_text(pCtx, "fts5: 2022-12-28 14:03:47 df5c253c0b3dd24916e4ec7cf77d3db5294cc9fd45ae7b9c5e82ad8197f38a24", -1, SQLITE_TRANSIENT);
 }
 
 /*