HLR H35010
Except for the read operation required by H35070 and those reads made
as part of opening a read-only transaction, SQLite shall ensure that
a database connection has an open read-only or read/write
transaction when any data is read from the database file.
HLR H35020
Aside from those read operations described by H35070 and H21XXX, SQLite
shall read data from the database file in aligned blocks of
page-size bytes, where page-size is the database page size
used by the database file.
HLR H35030
While opening a read-only transaction, after successfully
obtaining a shared lock on the database file, SQLite shall
attempt to detect and roll back a hot journal file associated
with the same database file.
HLR H35040
Assuming no errors have occurred, then after attempting to detect and
roll back a hot journal file, if the page cache contains
any entries associated with the current database connection,
then SQLite shall validate the contents of the page cache by
testing the file change counter. This procedure is known as
cache validation.
HLR H35050
If the cache validate procedure prescribed by H35040 is required and
does not prove that the page cache entries associated with the
current database connection are valid, then SQLite shall discard
all entries associated with the current database connection from
the page cache.
HLR H35060
When a new database connection is required, SQLite shall attempt
to open a file-handle on the database file. If the attempt fails, then
no new database connection is created and an error returned.
HLR H35070
When a new database connection is required, after opening the
new file-handle, SQLite shall attempt to read the first 100 bytes
of the database file. If the attempt fails for any other reason than
that the opened file is less than 100 bytes in size, then
the file-handle is closed, no new database connection is created
and an error returned instead.
HLR H35080
If the database file header is successfully read from a newly
opened database file, the connections expected page-size shall
be set to the value stored in the page-size field of the
database header.
HLR H35090
If the database file header cannot be read from a newly opened
database file (because the file is less than 100 bytes in size), the
connections expected page-size shall be set to the compile time
value of the SQLITE_DEFAULT_PAGESIZE option.
HLR H35100
When required to open a read-only transaction using a
database connection, SQLite shall first attempt to obtain
a shared-lock on the file-handle open on the database file.
HLR H35110
If, while opening a read-only transaction, SQLite fails to obtain
the shared-lock on the database file, then the process is
abandoned, no transaction is opened and an error returned to the user.
HLR H35120
If, while opening a read-only transaction, SQLite encounters
an error while attempting to detect or roll back a hot journal
file, then the shared-lock on the database file is released,
no transaction is opened and an error returned to the user.
HLR H35130
When required to end a read-only transaction, SQLite shall
relinquish the shared lock held on the database file by
calling the xUnlock() method of the file-handle.
HLR H35140
When required to attempt to detect a hot-journal file, SQLite
shall first use the xAccess() method of the VFS layer to check if a
journal file exists in the file-system.
HLR H35150
When required to attempt to detect a hot-journal file, if the
call to xAccess() required by H35140 indicates that a journal file does
not exist, then SQLite shall conclude that there is no hot-journal
file in the file system and therefore that no hot journal
rollback is required.
HLR H35160
When required to attempt to detect a hot-journal file, if the
call to xAccess() required by H35140 indicates that a journal file
is present, then the xCheckReservedLock() method of the database file
file-handle is invoked to determine whether or not some other
process is holding a reserved or greater lock on the database
file.
HLR H35170
If the call to xCheckReservedLock() required by H35160 indicates that
some other database connection is holding a reserved
or greater lock on the database file, then SQLite shall conclude that
there is no hot journal file. In this case the attempt to detect
a hot journal file is concluded.
HLR H35180
When a file-handle open on a database file is unlocked, if the
page cache contains one or more entries belonging to the
associated database connection, SQLite shall store the value
of the file change counter internally.
HLR H35190
When required to perform cache validation as part of opening
a read transaction, SQLite shall read a 16 byte block
starting at byte offset 24 of the database file using the xRead()
method of the database connections file handle.
HLR H35200
While performing cache validation, after loading the 16 byte
block as required by H35190, SQLite shall compare the 32-bit big-endian
integer stored in the first 4 bytes of the block to the most
recently stored value of the file change counter (see H35180).
If the values are not the same, then SQLite shall conclude that
the contents of the cache are invalid.
HLR H35210
During the conclusion of a read transaction, before unlocking
the database file, SQLite shall set the connections
expected page size to the current database page-size.
HLR H35220
As part of opening a new read transaction, immediately after
performing cache validation, if there is no data for database
page 1 in the page cache, SQLite shall read N bytes from
the start of the database file using the xRead() method of the
connections file handle, where N is the connections current
expected page size value.
HLR H35230
If page 1 data is read as required by H35230, then the value of the
page-size field that appears in the database file header that
consumes the first 100 bytes of the read block is not the same as the
connections current expected page size, then the
expected page size is set to this value, the database file is
unlocked and the entire procedure to open a read transaction
is repeated.
HLR H35240
If page 1 data is read as required by H35230, then the value of the
page-size field that appears in the database file header that
consumes the first 100 bytes of the read block is the same as the
connections current expected page size, then the block of data
read is stored in the page cache as page 1.
HLR H35270
When required to journal a database page, SQLite shall first
append the page number of the page being journalled to the
journal file, formatted as a 4-byte big-endian unsigned integer,
using a single call to the xWrite method of the file-handle opened
on the journal file.
HLR H35280
When required to journal a database page, if the attempt to
append the page number to the journal file is successful,
then the current page data (page-size bytes) shall be appended
to the journal file, using a single call to the xWrite method of the
file-handle opened on the journal file.
HLR H35290
When required to journal a database page, if the attempt to
append the current page data to the journal file is successful,
then SQLite shall append a 4-byte big-endian integer checksum value
to the to the journal file, using a single call to the xWrite method
of the file-handle opened on the journal file.
HLR H35300
The checksum value written to the journal file by the write
required by H35290 shall be equal to the sum of the checksum
initializer field stored in the journal header (H35700) and
every 200th byte of the page data, beginning with the
(page-size % 200)th byte.
HLR H35350
When required to open a write transaction on the database,
SQLite shall first open a read transaction, if the database
connection in question has not already opened one.
HLR H35360
When required to open a write transaction on the database, after
ensuring a read transaction has already been opened, SQLite
shall obtain a reserved lock on the database file by calling
the xLock method of the file-handle open on the database file.
HLR H35370
When required to open a write transaction on the database, after
obtaining a reserved lock on the database file, SQLite shall
open a read/write file-handle on the corresponding journal file.
HLR H35380
When required to open a write transaction on the database, after
opening a file-handle on the journal file, SQLite shall append
a journal header to the (currently empty) journal file.
HLR H35400
When a database connection is closed, SQLite shall close the
associated file handle at the VFS level.
HLR H35420
SQLite shall ensure that a database connection has an open
read-only or read/write transaction before using data stored in the page
cache to satisfy user queries.
HLR H35430
When a database connection is closed, all associated page
cache entries shall be discarded.
HLR H35440
If while attempting to detect a hot-journal file the call to
xCheckReservedLock() indicates that no process holds a reserved
or greater lock on the database file, then SQLite shall open
a file handle on the potentially hot journal file using the VFS xOpen()
method.
HLR H35450
After successfully opening a file-handle on a potentially hot journal
file, SQLite shall query the file for its size in bytes using the
xFileSize() method of the open file handle.
HLR H35460
If the size of a potentially hot journal file is revealed to be zero
bytes by a query required by H35450, then SQLite shall close the
file handle opened on the journal file and delete the journal file using
a call to the VFS xDelete() method. In this case SQLite shall conclude
that there is no hot journal file.
HLR H35470
If the size of a potentially hot journal file is revealed to be greater
than zero bytes by a query required by H35450, then SQLite shall attempt
to upgrade the shared lock held by the database connection
on the database file directly to an exclusive lock.
HLR H35480
If an attempt to upgrade to an exclusive lock prescribed by
H35470 fails for any reason, then SQLite shall release all locks held by
the database connection and close the file handle opened on the
journal file. The attempt to open a read-only transaction
shall be deemed to have failed and an error returned to the user.
HLR H35490
If, as part of the hot journal file detection process, the
attempt to upgrade to an exclusive lock mandated by H35470 is
successful, then SQLite shall query the file-system using the xAccess()
method of the VFS implementation to test whether or not the journal
file is still present in the file-system.
HLR H35500
If the xAccess() query required by H35490 reveals that the journal
file is still present in the file system, then SQLite shall conclude
that the journal file is a hot journal file that needs to
be rolled back. SQLite shall immediately begin hot journal
rollback.
HLR H35510
If the call to xAccess() required by H35140 fails (due to an IO error or
similar), then SQLite shall abandon the attempt to open a read-only
transaction, relinquish the shared lock held on the database
file and return an error to the user.
HLR H35520
If the call to xCheckReservedLock() required by H35160 fails (due to an
IO or other internal VFS error), then SQLite shall abandon the attempt
to open a read-only transaction, relinquish the shared lock
held on the database file and return an error to the user.
HLR H35530
If the call to xOpen() required by H35440 fails (due to an IO or other
internal VFS error), then SQLite shall abandon the attempt to open a
read-only transaction, relinquish the shared lock held on
the database file and return an error to the user.
HLR H35540
If the call to xFileSize() required by H35450 fails (due to an IO or
other internal VFS error), then SQLite shall abandon the attempt to open
a read-only transaction, relinquish the shared lock held on
the database file, close the file handle opened on the journal file and
return an error to the user.
HLR H35550
If the call to xDelete() required by H35450 fails (due to an IO or
other internal VFS error), then SQLite shall abandon the attempt to open
a read-only transaction, relinquish the shared lock held on
the database file and return an error to the user.
HLR H35560
If the call to xAccess() required by H35490 fails (due to an IO or
other internal VFS error), then SQLite shall abandon the attempt to open
a read-only transaction, relinquish the lock held on the
database file, close the file handle opened on the journal file and
return an error to the user.
HLR H35570
If the call to xAccess() required by H35490 reveals that the journal
file is no longer present in the file system, then SQLite shall abandon
the attempt to open a read-only transaction, relinquish the
lock held on the database file, close the file handle opened on the
journal file and return an SQLITE_BUSY error to the user.
HLR H35580
If an attempt to acquire a reserved lock prescribed by
requirement H35360 fails, then SQLite shall deem the attempt to
open a write transaction to have failed and return an error
to the user.
HLR H35590
When required to modify the contents of an existing database page that
existed and was not a free-list leaf page when the write
transaction was opened, SQLite shall journal the page if it has not
already been journalled within the current write transaction.
HLR H35600
When required to modify the contents of an existing database page,
SQLite shall update the cached version of the database page content
stored as part of the page cache entry associated with the page.
HLR H35610
When required to append a new database page to the database file,
SQLite shall create a new page cache entry corresponding to
the new page and insert it into the page cache. The dirty
flag of the new page cache entry shall be set.
HLR H35620
When required to truncate (remove) a database page that existed and was
not a free-list leaf page when the write transaction was
opened from the end of a database file, SQLite shall journal the page if
it has not already been journalled within the current write
transaction.
HLR H35630
When required to truncate a database page from the end of the database
file, SQLite shall discard the associated page cache entry
from the page cache.
HLR H35640
When required to purge a non-writable dirty page from the
page cache, SQLite shall sync the journal file before
proceeding with the write operation required by H35670.
HLR H35660
After syncing the journal file as required by H35640, SQLite
shall append a new journal header to the journal file
before proceeding with the write operation required by H35670.
HLR H35670
When required to purge a page cache entry that is a
dirty page SQLite shall write the page data into the database
file, using a single call to the xWrite method of the database
connection file handle.
HLR H35680
When required to append a journal header to the journal
file, SQLite shall do so by writing a block of sector-size
bytes using a single call to the xWrite method of the file-handle
open on the journal file. The block of data written shall begin
at the smallest sector-size aligned offset at or following the current
end of the journal file.
HLR H35690
The first 8 bytes of the journal header required to be written
by H35680 shall contain the following values, in order from byte offset 0
to 7: 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63 and 0xd7.
HLR H35700
Bytes 8-11 of the journal header required to be written by
H35680 shall contain 0x00.
HLR H35710
Bytes 12-15 of the journal header required to be written by
H35680 shall contain the number of pages that the database file
contained when the current write-transaction was started,
formatted as a 4-byte big-endian unsigned integer.
HLR H35720
Bytes 16-19 of the journal header required to be written by
H35680 shall contain pseudo-randomly generated values.
HLR H35730
Bytes 20-23 of the journal header required to be written by
H35680 shall contain the sector size used by the VFS layer,
formatted as a 4-byte big-endian unsigned integer.
HLR H35740
Bytes 24-27 of the journal header required to be written by
H35680 shall contain the page size used by the database at
the start of the write transaction, formatted as a 4-byte
big-endian unsigned integer.
HLR H35750
When required to sync the journal file, SQLite shall invoke the
xSync method of the file handle open on the journal file.
HLR H35760
When required to sync the journal file, after invoking the
xSync method as required by H35750, SQLite shall update the record
count of the journal header most recently written to the
journal file. The 4-byte field shall be updated to contain
the number of journal records that have been written to the
journal file since the journal header was written,
formatted as a 4-byte big-endian unsigned integer.
HLR H35770
When required to sync the journal file, after updating the
record count field of a journal header as required by
H35760, SQLite shall invoke the xSync method of the file handle open
on the journal file.
HLR H35780
When required to upgrade to an exclusive lock as part of a write
transaction, SQLite shall first attempt to obtain a pending lock
on the database file if one is not already held by invoking the xLock
method of the file handle opened on the database file.
HLR H35790
When required to upgrade to an exclusive lock as part of a write
transaction, after successfully obtaining a pending lock SQLite
shall attempt to obtain an exclusive lock by invoking the
xLock method of the file handle opened on the database file.
HLR H35800
When required to commit a write-transaction, SQLite shall
modify page 1 to increment the value stored in the change counter
field of the database file header.
HLR H35810
When required to commit a write-transaction, after incrementing
the change counter field, SQLite shall sync the journal
file.
HLR H35820
When required to commit a write-transaction, after syncing
the journal file as required by H35810, if an exclusive lock
on the database file is not already held, SQLite shall attempt to
upgrade to an exclusive lock.
HLR H35830
When required to commit a write-transaction, after syncing
the journal file as required by H35810 and ensuring that an
exclusive lock is held on the database file as required by
H35830, SQLite shall copy the contents of all dirty page
stored in the page cache into the database file using
calls to the xWrite method of the database connection file
handle. Each call to xWrite shall write the contents of a single
dirty page (page-size bytes of data) to the database
file. Dirty pages shall be written in order of page number,
from lowest to highest.
HLR H35840
When required to commit a write-transaction, after copying the
contents of any dirty pages to the database file as required
by H35830, SQLite shall sync the database file by invoking the xSync
method of the database connection file handle.
HLR H35850
When required to commit a write-transaction, after syncing
the database file as required by H35840, SQLite shall close the
file-handle opened on the journal file and delete the
journal file from the file system via a call to the VFS
xDelete method.
HLR H35860
When required to commit a write-transaction, after deleting
the journal file as required by H35850, SQLite shall relinquish
all locks held on the database file by invoking the xUnlock
method of the database connection file handle.