Return to wal.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src

Annotation of embedaddon/sqlite3/src/wal.h, revision 1.1

1.1     ! misho       1: /*
        !             2: ** 2010 February 1
        !             3: **
        !             4: ** The author disclaims copyright to this source code.  In place of
        !             5: ** a legal notice, here is a blessing:
        !             6: **
        !             7: **    May you do good and not evil.
        !             8: **    May you find forgiveness for yourself and forgive others.
        !             9: **    May you share freely, never taking more than you give.
        !            10: **
        !            11: *************************************************************************
        !            12: ** This header file defines the interface to the write-ahead logging 
        !            13: ** system. Refer to the comments below and the header comment attached to 
        !            14: ** the implementation of each function in log.c for further details.
        !            15: */
        !            16: 
        !            17: #ifndef _WAL_H_
        !            18: #define _WAL_H_
        !            19: 
        !            20: #include "sqliteInt.h"
        !            21: 
        !            22: /* Additional values that can be added to the sync_flags argument of
        !            23: ** sqlite3WalFrames():
        !            24: */
        !            25: #define WAL_SYNC_TRANSACTIONS  0x20   /* Sync at the end of each transaction */
        !            26: #define SQLITE_SYNC_MASK       0x13   /* Mask off the SQLITE_SYNC_* values */
        !            27: 
        !            28: #ifdef SQLITE_OMIT_WAL
        !            29: # define sqlite3WalOpen(x,y,z)                   0
        !            30: # define sqlite3WalLimit(x,y)
        !            31: # define sqlite3WalClose(w,x,y,z)                0
        !            32: # define sqlite3WalBeginReadTransaction(y,z)     0
        !            33: # define sqlite3WalEndReadTransaction(z)
        !            34: # define sqlite3WalRead(v,w,x,y,z)               0
        !            35: # define sqlite3WalDbsize(y)                     0
        !            36: # define sqlite3WalBeginWriteTransaction(y)      0
        !            37: # define sqlite3WalEndWriteTransaction(x)        0
        !            38: # define sqlite3WalUndo(x,y,z)                   0
        !            39: # define sqlite3WalSavepoint(y,z)
        !            40: # define sqlite3WalSavepointUndo(y,z)            0
        !            41: # define sqlite3WalFrames(u,v,w,x,y,z)           0
        !            42: # define sqlite3WalCheckpoint(r,s,t,u,v,w,x,y,z) 0
        !            43: # define sqlite3WalCallback(z)                   0
        !            44: # define sqlite3WalExclusiveMode(y,z)            0
        !            45: # define sqlite3WalHeapMemory(z)                 0
        !            46: #else
        !            47: 
        !            48: #define WAL_SAVEPOINT_NDATA 4
        !            49: 
        !            50: /* Connection to a write-ahead log (WAL) file. 
        !            51: ** There is one object of this type for each pager. 
        !            52: */
        !            53: typedef struct Wal Wal;
        !            54: 
        !            55: /* Open and close a connection to a write-ahead log. */
        !            56: int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *, int, i64, Wal**);
        !            57: int sqlite3WalClose(Wal *pWal, int sync_flags, int, u8 *);
        !            58: 
        !            59: /* Set the limiting size of a WAL file. */
        !            60: void sqlite3WalLimit(Wal*, i64);
        !            61: 
        !            62: /* Used by readers to open (lock) and close (unlock) a snapshot.  A 
        !            63: ** snapshot is like a read-transaction.  It is the state of the database
        !            64: ** at an instant in time.  sqlite3WalOpenSnapshot gets a read lock and
        !            65: ** preserves the current state even if the other threads or processes
        !            66: ** write to or checkpoint the WAL.  sqlite3WalCloseSnapshot() closes the
        !            67: ** transaction and releases the lock.
        !            68: */
        !            69: int sqlite3WalBeginReadTransaction(Wal *pWal, int *);
        !            70: void sqlite3WalEndReadTransaction(Wal *pWal);
        !            71: 
        !            72: /* Read a page from the write-ahead log, if it is present. */
        !            73: int sqlite3WalRead(Wal *pWal, Pgno pgno, int *pInWal, int nOut, u8 *pOut);
        !            74: 
        !            75: /* If the WAL is not empty, return the size of the database. */
        !            76: Pgno sqlite3WalDbsize(Wal *pWal);
        !            77: 
        !            78: /* Obtain or release the WRITER lock. */
        !            79: int sqlite3WalBeginWriteTransaction(Wal *pWal);
        !            80: int sqlite3WalEndWriteTransaction(Wal *pWal);
        !            81: 
        !            82: /* Undo any frames written (but not committed) to the log */
        !            83: int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx);
        !            84: 
        !            85: /* Return an integer that records the current (uncommitted) write
        !            86: ** position in the WAL */
        !            87: void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData);
        !            88: 
        !            89: /* Move the write position of the WAL back to iFrame.  Called in
        !            90: ** response to a ROLLBACK TO command. */
        !            91: int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData);
        !            92: 
        !            93: /* Write a frame or frames to the log. */
        !            94: int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
        !            95: 
        !            96: /* Copy pages from the log to the database file */ 
        !            97: int sqlite3WalCheckpoint(
        !            98:   Wal *pWal,                      /* Write-ahead log connection */
        !            99:   int eMode,                      /* One of PASSIVE, FULL and RESTART */
        !           100:   int (*xBusy)(void*),            /* Function to call when busy */
        !           101:   void *pBusyArg,                 /* Context argument for xBusyHandler */
        !           102:   int sync_flags,                 /* Flags to sync db file with (or 0) */
        !           103:   int nBuf,                       /* Size of buffer nBuf */
        !           104:   u8 *zBuf,                       /* Temporary buffer to use */
        !           105:   int *pnLog,                     /* OUT: Number of frames in WAL */
        !           106:   int *pnCkpt                     /* OUT: Number of backfilled frames in WAL */
        !           107: );
        !           108: 
        !           109: /* Return the value to pass to a sqlite3_wal_hook callback, the
        !           110: ** number of frames in the WAL at the point of the last commit since
        !           111: ** sqlite3WalCallback() was called.  If no commits have occurred since
        !           112: ** the last call, then return 0.
        !           113: */
        !           114: int sqlite3WalCallback(Wal *pWal);
        !           115: 
        !           116: /* Tell the wal layer that an EXCLUSIVE lock has been obtained (or released)
        !           117: ** by the pager layer on the database file.
        !           118: */
        !           119: int sqlite3WalExclusiveMode(Wal *pWal, int op);
        !           120: 
        !           121: /* Return true if the argument is non-NULL and the WAL module is using
        !           122: ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
        !           123: ** WAL module is using shared-memory, return false. 
        !           124: */
        !           125: int sqlite3WalHeapMemory(Wal *pWal);
        !           126: 
        !           127: #endif /* ifndef SQLITE_OMIT_WAL */
        !           128: #endif /* _WAL_H_ */