database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-07-29 08:01:23 +03:00
Code Activity

Doc updates in JS code. No functional changes.

Browse Source 
FossilOrigin-Name: 587ed3a5d283898ad0e67ccee86a0a4ccc432fa292c0a3534e9e6ec70a7b7780
This commit is contained in:
stephan
2024-06-12 12:17:03 +00:00
parent 6975fc56f7
commit 01f07a61e4
4 changed files with 41 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
ext/wasm/api/sqlite3-opfs-async-proxy.js
View File

@ -173,10 +173,10 @@ const installAsyncProxy = function(){
/**
If the given file-holding object has a sync handle attached to it,
that handle is remove and asynchronously closed. Though it may
that handle is removed and asynchronously closed. Though it may
sound sensible to continue work as soon as the close() returns
(noting that it's asynchronous), doing so can cause operations
performed soon afterwards, e.g. a call to getSyncHandle() to fail
performed soon afterwards, e.g. a call to getSyncHandle(), to fail
because they may happen out of order from the close(). OPFS does
not guaranty that the actual order of operations is retained in
such cases. i.e. always "await" on the result of this function.
@ -293,6 +293,20 @@ const installAsyncProxy = function(){
times. If acquisition still fails at that point it will give up
and propagate the exception. Client-level code will see that as
an I/O error.
2024-06-12: there is a rare race condition here which has been
reported a single time:
https://sqlite.org/forum/forumpost/9ee7f5340802d600
What appears to be happening is that file we're waiting for a
lock on is deleted while we wait. What currently happens here is
that a locking exception is thrown but the exception type is
NotFoundError. In such cases, we very probably should attempt to
re-open/re-create the file an obtain the lock on it (noting that
there's another race condition there). That's easy to say but
creating a viable test for that condition has proven challenging
so far.
*/
const getSyncHandle = async (fh,opName)=>{
if(!fh.syncHandle){
@ -674,8 +688,10 @@ const installAsyncProxy = function(){
mTimeStart('xUnlock');
let rc = 0;
const fh = __openFiles[fid];
if( state.sq3Codes.SQLITE_LOCK_NONE===lockType
&& fh.syncHandle ){
if( fh.syncHandle
&& state.sq3Codes.SQLITE_LOCK_NONE===lockType
/* Note that we do not differentiate between lock types in
this VFS. We're either locked or unlocked. */ ){
wTimeStart('xUnlock');
try { await closeSyncHandle(fh) }
catch(e){

26
ext/wasm/common/whwasmutil.js
View File

@ -156,8 +156,7 @@
- 'dealloc()` must behave like C's `free()`, accepting either a
pointer returned from its allocation counterpart or the values
null/0 (for which it must be a no-op). allocating N bytes of
memory and returning its pointer. In Emscripten this is
null/0 (for which it must be a no-op). In Emscripten this is
conventionally made available via `Module['_free']`.
APIs which require allocation routines are explicitly documented as
@ -730,22 +729,23 @@ globalThis.WhWasmUtilInstaller = function(target){
};
/**
The counterpart of peek(), this sets a numeric value at
the given WASM heap address, using the type to define how many
bytes are written. Throws if given an invalid type. See
peek() for details about the type argument. If the 3rd
argument ends with `*` then it is treated as a pointer type and
this function behaves as if the 3rd argument were `i32`.
The counterpart of peek(), this sets a numeric value at the given
WASM heap address, using the 3rd argument to define how many
bytes are written. Throws if given an invalid type. See peek()
for details about the `type` argument. If the 3rd argument ends
with `*` then it is treated as a pointer type and this function
behaves as if the 3rd argument were `i32`.
If the first argument is an array, it is treated like a list
of pointers and the given value is written to each one.
Returns `this`. (Prior to 2022-12-09 it returns this function.)
Returns `this`. (Prior to 2022-12-09 it returned this function.)
ACHTUNG: calling this often, e.g. in a loop, can have a noticably
painful impact on performance. Rather than doing so, use
heapForSize() to fetch the heap object and assign directly to it
or use the heap's set() method.
ACHTUNG: calling this often, e.g. in a loop to populate a large
chunk of memory, can have a noticably painful impact on
performance. Rather than doing so, use heapForSize() to fetch the
heap object and assign directly to it or use the heap's set()
method.
*/
target.poke = function(ptr, value, type='i8'){
if (type.endsWith('*')) type = ptrIR;