147 lines
5.5 KiB
C
147 lines
5.5 KiB
C
/*
|
|
** 2010 February 1
|
|
**
|
|
** 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 header file defines the interface to the write-ahead logging
|
|
** system. Refer to the comments below and the header comment attached to
|
|
** the implementation of each function in log.c for further details.
|
|
*/
|
|
|
|
#ifndef _WAL_H_
|
|
#define _WAL_H_
|
|
|
|
#include "sqliteInt.h"
|
|
|
|
/* Additional values that can be added to the sync_flags argument of
|
|
** sqlite3WalFrames():
|
|
*/
|
|
#define WAL_SYNC_TRANSACTIONS 0x20 /* Sync at the end of each transaction */
|
|
#define SQLITE_SYNC_MASK 0x13 /* Mask off the SQLITE_SYNC_* values */
|
|
|
|
#ifdef SQLITE_OMIT_WAL
|
|
# define sqlite3WalOpen(x,y,z) 0
|
|
# define sqlite3WalLimit(x,y)
|
|
# define sqlite3WalClose(w,x,y,z) 0
|
|
# define sqlite3WalBeginReadTransaction(y,z) 0
|
|
# define sqlite3WalEndReadTransaction(z)
|
|
# define sqlite3WalDbsize(y) 0
|
|
# define sqlite3WalBeginWriteTransaction(y) 0
|
|
# define sqlite3WalEndWriteTransaction(x) 0
|
|
# define sqlite3WalUndo(x,y,z) 0
|
|
# define sqlite3WalSavepoint(y,z)
|
|
# define sqlite3WalSavepointUndo(y,z) 0
|
|
# define sqlite3WalFrames(u,v,w,x,y,z) 0
|
|
# define sqlite3WalCheckpoint(r,s,t,u,v,w,x,y,z) 0
|
|
# define sqlite3WalCallback(z) 0
|
|
# define sqlite3WalExclusiveMode(y,z) 0
|
|
# define sqlite3WalHeapMemory(z) 0
|
|
# define sqlite3WalFramesize(z) 0
|
|
# define sqlite3WalFindFrame(x,y,z) 0
|
|
# define sqlite3WalFile(x) 0
|
|
#else
|
|
|
|
#define WAL_SAVEPOINT_NDATA 4
|
|
|
|
/* Connection to a write-ahead log (WAL) file.
|
|
** There is one object of this type for each pager.
|
|
*/
|
|
typedef struct Wal Wal;
|
|
|
|
/* Open and close a connection to a write-ahead log. */
|
|
int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *, int, i64, Wal**);
|
|
int sqlite3WalClose(Wal *pWal, int sync_flags, int, u8 *);
|
|
|
|
/* Set the limiting size of a WAL file. */
|
|
void sqlite3WalLimit(Wal*, i64);
|
|
|
|
/* Used by readers to open (lock) and close (unlock) a snapshot. A
|
|
** snapshot is like a read-transaction. It is the state of the database
|
|
** at an instant in time. sqlite3WalOpenSnapshot gets a read lock and
|
|
** preserves the current state even if the other threads or processes
|
|
** write to or checkpoint the WAL. sqlite3WalCloseSnapshot() closes the
|
|
** transaction and releases the lock.
|
|
*/
|
|
int sqlite3WalBeginReadTransaction(Wal *pWal, int *);
|
|
void sqlite3WalEndReadTransaction(Wal *pWal);
|
|
|
|
/* Read a page from the write-ahead log, if it is present. */
|
|
int sqlite3WalFindFrame(Wal *, Pgno, u32 *);
|
|
int sqlite3WalReadFrame(Wal *, u32, int, u8 *);
|
|
|
|
/* If the WAL is not empty, return the size of the database. */
|
|
Pgno sqlite3WalDbsize(Wal *pWal);
|
|
|
|
/* Obtain or release the WRITER lock. */
|
|
int sqlite3WalBeginWriteTransaction(Wal *pWal);
|
|
int sqlite3WalEndWriteTransaction(Wal *pWal);
|
|
|
|
/* Undo any frames written (but not committed) to the log */
|
|
int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx);
|
|
|
|
/* Return an integer that records the current (uncommitted) write
|
|
** position in the WAL */
|
|
void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData);
|
|
|
|
/* Move the write position of the WAL back to iFrame. Called in
|
|
** response to a ROLLBACK TO command. */
|
|
int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData);
|
|
|
|
/* Write a frame or frames to the log. */
|
|
int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
|
|
|
|
/* Copy pages from the log to the database file */
|
|
int sqlite3WalCheckpoint(
|
|
Wal *pWal, /* Write-ahead log connection */
|
|
int eMode, /* One of PASSIVE, FULL and RESTART */
|
|
int (*xBusy)(void*), /* Function to call when busy */
|
|
void *pBusyArg, /* Context argument for xBusyHandler */
|
|
int sync_flags, /* Flags to sync db file with (or 0) */
|
|
int nBuf, /* Size of buffer nBuf */
|
|
u8 *zBuf, /* Temporary buffer to use */
|
|
int *pnLog, /* OUT: Number of frames in WAL */
|
|
int *pnCkpt /* OUT: Number of backfilled frames in WAL */
|
|
);
|
|
|
|
/* Return the value to pass to a sqlite3_wal_hook callback, the
|
|
** number of frames in the WAL at the point of the last commit since
|
|
** sqlite3WalCallback() was called. If no commits have occurred since
|
|
** the last call, then return 0.
|
|
*/
|
|
int sqlite3WalCallback(Wal *pWal);
|
|
|
|
/* Tell the wal layer that an EXCLUSIVE lock has been obtained (or released)
|
|
** by the pager layer on the database file.
|
|
*/
|
|
int sqlite3WalExclusiveMode(Wal *pWal, int op);
|
|
|
|
/* Return true if the argument is non-NULL and the WAL module is using
|
|
** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
|
|
** WAL module is using shared-memory, return false.
|
|
*/
|
|
int sqlite3WalHeapMemory(Wal *pWal);
|
|
|
|
#ifdef SQLITE_ENABLE_SNAPSHOT
|
|
int sqlite3WalSnapshotGet(Wal *pWal, sqlite3_snapshot **ppSnapshot);
|
|
void sqlite3WalSnapshotOpen(Wal *pWal, sqlite3_snapshot *pSnapshot);
|
|
#endif
|
|
|
|
#ifdef SQLITE_ENABLE_ZIPVFS
|
|
/* If the WAL file is not empty, return the number of bytes of content
|
|
** stored in each frame (i.e. the db page-size when the WAL was created).
|
|
*/
|
|
int sqlite3WalFramesize(Wal *pWal);
|
|
#endif
|
|
|
|
/* Return the sqlite3_file object for the WAL file */
|
|
sqlite3_file *sqlite3WalFile(Wal *pWal);
|
|
|
|
#endif /* ifndef SQLITE_OMIT_WAL */
|
|
#endif /* _WAL_H_ */
|