python-apsw-doc 3.7.6.3-r1-1build1 / usr / share / doc / python-apsw / html / _sources / apsw.txt

.. Automatically generated by code2rst.py
   code2rst.py src/apsw.c doc/apsw.rst
   Edit src/apsw.c not this file!

.. module:: apsw
   :synopsis: Python access to SQLite database library

APSW Module
***********

The module is the main interface to SQLite.  Methods and data on the
module have process wide effects.  You can instantiate the
:class:`Connection` and :class:`zeroblob` objects using
:meth:`Connection` and :meth:`zeroblob` respectively.

API Reference
=============

.. data:: SQLITE_VERSION_NUMBER

    The integer version number of SQLite that APSW was compiled
    against.  For example SQLite 3.6.4 will have the value *3006004*.
    This number may be different than the actual library in use if the
    library is shared and has been updated.  Call
    :meth:`sqlitelibversion` to get the actual library version.

.. method:: apswversion() -> string

  Returns the APSW version.

.. method:: async_control(op[, params])

    :param op: The operation code (eg SQLITE_ASYNC_HALT)
    :param params: Optional additional parameters depending on the opcode.
    :returns: None or additional information requested

    This table summarises the parameters taken and value returned
    depending on the operation.

    +-----------------------------------+--------------+---------+
    | op                                | params       | result  |
    +===================================+==============+=========+
    | SQLITEASYNC_HALT                  | int          | None    |
    +-----------------------------------+--------------+---------+
    | SQLITEASYNC_GET_HALT              |              | int     |
    +-----------------------------------+--------------+---------+
    | SQLITEASYNC_DELAY                 | int          | None    |
    +-----------------------------------+--------------+---------+
    | SQLITEASYNC_GET_DELAY             |              | int     |
    +-----------------------------------+--------------+---------+
    | SQLITEASYNC_LOCKFILES             | int          | None    |
    +-----------------------------------+--------------+---------+
    | SQLITEASYNC_GET_LOCKFILES         |              | int     |
    +-----------------------------------+--------------+---------+

.. method:: async_initialize(parentvfs, makedefault) -> string

  Registers the asyncvfs.  It is safe to call this method multiple
  times, with subsequent calls having no effect.

  :param parentvfs: Name of the vfs to use for I/O operations.  Use an empty string for the default
  :param makedefault: Make the async vfs be the default vfs.
  :returns: A string containg the name of the default vfs.

  Note that this method cannot return string errors as part of
  exceptions, just generic error codes and messages.  For example if
  you specify a non-existent parentvfs then you just get
  :exc:`apsw.SQLError` with the text `error`.  The `source
  <http://www.sqlite.org/src/finfo?name=ext/async/sqlite3async.h>`__
  lists what error codes could be returned.

  .. seealso::

  * :ref:`ext-asyncvfs`

.. method:: async_run()

  Call this method from a worker thread and it will do all the
  asynchronous I/O.  You can get the function to exit by calling
  :func:`async_control` with a first parameter of :const:`SQLITEASYNC_HALT` and
  a second parameter of :const:`SQLITEASYNC_HALT_NOW`.

.. method:: async_shutdown()

  Unregisters the asyncvfs.  It is safe to call this method multiple
  times with subsequent calls having no effect.  It is not recommended
  that you call this method.  It deallocates everything immediately
  making no checks if anything is in use.  If you want to call it then
  only do so once you are absolutely sure that all databases, files,
  vfs, threads and other objects it references have been closed and
  freed.

.. index:: sqlite3_compileoption_get

.. attribute:: compile_options

    A tuple of the options used to compile SQLite.  For example it
    will be something like this::

        ('ENABLE_LOCKING_STYLE=0', 'TEMP_STORE=1', 'THREADSAFE=1')

    Calls: :sqliteapi:`sqlite3_compileoption_get <compileoption_get>`

.. index:: sqlite3_complete

.. method:: complete(statement) -> bool

  Returns True if the input string comprises one or more complete SQL
  statements by looking for an unquoted trailing semi-colon.

  An example use would be if you were prompting the user for SQL
  statements and needed to know if you had a whole statement, or
  needed to ask for another line::

    statement=raw_input("SQL> ")
    while not apsw.complete(statement):
       more=raw_input("  .. ")
       statement=statement+"\n"+more

  Calls: :sqliteapi:`sqlite3_complete <complete>`

.. index:: sqlite3_config

.. method:: config(op[, *args])

  :param op: A `configuration operation <http://sqlite.org/c3ref/c_config_chunkalloc.html>`_
  :param args: Zero or more arguments as appropriate for *op*

  Many operations don't make sense from a Python program.  Only the
  following configuration operations are supported: SQLITE_CONFIG_LOG,
  SQLITE_CONFIG_SINGLETHREAD, SQLITE_CONFIG_MULTITHREAD,
  SQLITE_CONFIG_SERIALIZED and SQLITE_CONFIG_MEMSTATUS.

  See :func:`log` for an example of using SQLITE_CONFIG_LOG.

  Calls: :sqliteapi:`sqlite3_config <config>`

.. attribute:: connection_hooks

       The purpose of the hooks is to allow the easy registration of
       :meth:`functions <Connection.createscalarfunction>`,
       :ref:`virtual tables <virtualtables>` or similar items with
       each :class:`Connection` as it is created. The default value is an empty
       list. Whenever a Connection is created, each item in
       apsw.connection_hooks is invoked with a single parameter being
       the new Connection object. If the hook raises an exception then
       the creation of the Connection fails.

       If you wanted to store your own defined functions in the
       database then you could define a hook that looked in the
       relevant tables, got the Python text and turned it into the
       functions.

.. index:: sqlite3_enable_shared_cache

.. method:: enablesharedcache(bool)

  If you use the same :class:`Connection` across threads or use
  multiple :class:`connections <Connection>` accessing the same file,
  then SQLite can `share the cache between them
  <http://www.sqlite.org/sharedcache.html>`_.  It is :ref:`not
  recommended <sharedcache>` that you use this.

  Calls: :sqliteapi:`sqlite3_enable_shared_cache <enable_shared_cache>`

.. method:: exceptionfor(int) -> Exception

  If you would like to raise an exception that corresponds to a
  particular SQLite `error code
  <http://sqlite.org/c3ref/c_abort.html>`_ then call this function.
  It also understands `extended error codes
  <http://sqlite.org/c3ref/c_ioerr_access.html>`_.

  For example to raise `SQLITE_IOERR_ACCESS <http://sqlite.org/c3ref/c_ioerr_access.html>`_::

    raise apsw.exceptionfor(apsw.SQLITE_IOERR_ACCESS)

.. method:: fork_checker()

  **Note** This method is not available on Windows as it does not
  support the fork system call.

  SQLite does not allow the use of database connections across `forked
  <http://en.wikipedia.org/wiki/Fork_(operating_system)>`__ processes
  (see the `SQLite FAQ Q6 <http://www.sqlite.org/faq.html#q6>`__).
  (Forking creates a child process that is a duplicate of the parent
  including the state of all data structures in the program.  If you
  do this to SQLite then parent and child would both consider
  themselves owners of open databases and silently corrupt each
  other's work and interfere with each other's locks.)

  One example of how you may end up using fork is if you use the
  `multiprocessing module
  <http://docs.python.org/library/multiprocessing.html>`__ which uses
  fork to make child processes.

  If you do use fork or multiprocessing on a platform that supports
  fork then you **must** ensure database connections and their objects
  (cursors, backup, blobs etc) are not used in the parent process, or
  are all closed before calling fork or starting a `Process
  <http://docs.python.org/library/multiprocessing.html#process-and-exceptions>`__.
  (Note you must call close to ensure the underlying SQLite objects
  are closed.  It is also a good idea to call `gc.collect(2)
  <http://docs.python.org/library/gc.html#gc.collect>`__ to ensure
  anything you may have missed is also deallocated.)

  Once you run this method, extra checking code is inserted into
  SQLite's mutex operations (at a very small performance penalty) that
  verifies objects are not used across processes.  You will get a
  :exc:`ForkingViolationError` if you do so.  Note that due to the way
  Python's internals work, the exception will be delivered to
  `sys.excepthook` in addition to the normal exception mechanisms and
  may be reported by Python after the line where the issue actually
  arose.  (Destructors of objects you didn't close also run between
  lines.)

  You should only call this method as the first line after importing
  APSW, as it has to shutdown and re-initialize SQLite.  If you have
  any SQLite objects already allocated when calling the method then
  the program will later crash.  The recommended use is to use the fork
  checking as part of your test suite.

.. method:: format_sql_value(value) -> string

  Returns a Python string (unicode) representing the supplied value in
  SQL syntax.  Python 2 note: You must supply unicode strings not
  plain strings.

.. index:: sqlite3_initialize

.. method:: initialize()

  It is unlikely you will want to call this method as SQLite automatically initializes.

  Calls: :sqliteapi:`sqlite3_initialize <initialize>`

.. index:: sqlite3_log

.. method:: log(level, message)

    Calls the SQLite logging interface.  Note that you must format the
    message before passing it to this method::

        apsw.log(apsw.SQLITE_NOMEM, "Need %d bytes of memory" % (1234,))

    To set your own logger use::

        def handler(errcode, message):
           print errcode, message
        apsw.config(apsw.SQLITE_CONFIG_LOG, handler)

    *handler* will be called with two arguments.  The first will be a
    numeric error code and the second will be a message string.  Note
    that the handler has to be set before any other calls to SQLite.
    Once SQLite is initialised you cannot change the logger - a
    :exc:`MisuseError` will happen (this restriction is in SQLite not
    APSW).

    Calls: :sqliteapi:`sqlite3_log <log>`

.. method:: main()

    Call this to run the interactive shell.  It automatically passes
    in sys.argv[1:] and exits Python when done.

.. index:: sqlite3_memory_highwater

.. method:: memoryhighwater(reset=False) -> int

  Returns the maximum amount of memory SQLite has used.  If *reset* is
  True then the high water mark is reset to the current value.

  .. seealso::

    :meth:`status`

  Calls: :sqliteapi:`sqlite3_memory_highwater <memory_highwater>`

.. index:: sqlite3_memory_used

.. method:: memoryused() -> int

  Returns the amount of memory SQLite is currently using.

  .. seealso::
    :meth:`status`

  Calls: :sqliteapi:`sqlite3_memory_used <memory_highwater>`

.. index:: sqlite3_randomness

.. method:: randomness(bytes)  -> data

  Gets random data from SQLite's random number generator.

  :param bytes: How many bytes to return
  :rtype: (Python 2) string, (Python 3) bytes

  Calls: :sqliteapi:`sqlite3_randomness <randomness>`

.. index:: sqlite3_release_memory

.. method:: releasememory(bytes) -> int

  Requests SQLite try to free *bytes* bytes of memory.  Returns how
  many bytes were freed.

  Calls: :sqliteapi:`sqlite3_release_memory <release_memory>`

.. index:: sqlite3_shutdown

.. method:: shutdown()

  It is unlikely you will want to call this method and there is no
  need to do so.  It is a **really** bad idea to call it unless you
  are absolutely sure all :class:`connections <Connection>`,
  :class:`blobs <blob>`, :class:`cursors <Cursor>`, :class:`vfs <VFS>`
  etc have been closed, deleted and garbage collected.

  Calls: :sqliteapi:`sqlite3_shutdown <initialize>`

.. index:: sqlite3_soft_heap_limit64

.. method:: softheaplimit(bytes) -> oldlimit

  Requests SQLite try to keep memory usage below *bytes* bytes and
  returns the previous setting.

  Calls: :sqliteapi:`sqlite3_soft_heap_limit64 <soft_heap_limit64>`

.. index:: sqlite3_libversion

.. method:: sqlitelibversion() -> string

  Returns the version of the SQLite library.  This value is queried at
  run time from the library so if you use shared libraries it will be
  the version in the shared library.

  Calls: :sqliteapi:`sqlite3_libversion <libversion>`

.. index:: sqlite3_status

.. method:: status(op, reset=False) -> (int, int)

  Returns current and highwater measurements.

  :param op: A `status parameter <http://sqlite.org/c3ref/c_status_malloc_size.html>`_
  :param reset: If *True* then the highwater is set to the current value
  :returns: A tuple of current value and highwater value

  .. seealso::

    * :ref:`Status example <example-status>`

  Calls: :sqliteapi:`sqlite3_status <status>`

.. attribute:: using_amalgamation

    If True then `SQLite amalgamation
    <http://www.sqlite.org/cvstrac/wiki?p=TheAmalgamation>`__ is in
    use (statically compiled into APSW).  Using the amalgamation means
    that SQLite shared libraries are not used and will not affect your
    code.

.. method:: vfsnames() -> list(string)

  Returns a list of the currently installed :ref:`vfs <vfs>`.  The first
  item in the list is the default vfs.

.. _sqliteconstants:

SQLite constants
================

SQLite has `many constants
<http://sqlite.org/c3ref/constlist.html>`_ used in various
interfaces.  To use a constant such as :const:`SQLITE_OK`, just
use ``apsw.SQLITE_OK``.

The same values can be used in different contexts. For example
:const:`SQLITE_OK` and :const:`SQLITE_CREATE_INDEX` both have a value
of zero. For each group of constants there is also a mapping (dict)
available that you can supply a string to and get the corresponding
numeric value, or supply a numeric value and get the corresponding
string. These can help improve diagnostics/logging, calling other
modules etc. For example::

      apsw.mapping_authorizer_function["SQLITE_READ"]=20
      apsw.mapping_authorizer_function[20]="SQLITE_READ"

.. data:: mapping_access

   `Flags for the xAccess VFS method <http://www.sqlite.org/c3ref/c_access_exists.html>`__

    :const:`SQLITE_ACCESS_EXISTS`, :const:`SQLITE_ACCESS_READ`, :const:`SQLITE_ACCESS_READWRITE`

.. data:: mapping_asyncvfs_control

   `asyncvfs <http://www.sqlite.org/src/dir?name=ext/async>`__ (if compiled in)

    :const:`SQLITEASYNC_DELAY`, :const:`SQLITEASYNC_GET_DELAY`, :const:`SQLITEASYNC_GET_HALT`, :const:`SQLITEASYNC_GET_LOCKFILES`, :const:`SQLITEASYNC_HALT`, :const:`SQLITEASYNC_LOCKFILES`

.. data:: mapping_asyncvfs_control_halt

   `asyncvfs <http://www.sqlite.org/src/dir?name=ext/async>`__ (if compiled in)

    :const:`SQLITEASYNC_HALT_IDLE`, :const:`SQLITEASYNC_HALT_NEVER`, :const:`SQLITEASYNC_HALT_NOW`

.. data:: mapping_authorizer_function

   `Authorizer Action Codes <http://www.sqlite.org/c3ref/c_alter_table.html>`__

    :const:`SQLITE_ALTER_TABLE`, :const:`SQLITE_ANALYZE`, :const:`SQLITE_ATTACH`, :const:`SQLITE_COPY`, :const:`SQLITE_CREATE_INDEX`, :const:`SQLITE_CREATE_TABLE`, :const:`SQLITE_CREATE_TEMP_INDEX`, :const:`SQLITE_CREATE_TEMP_TABLE`, :const:`SQLITE_CREATE_TEMP_TRIGGER`, :const:`SQLITE_CREATE_TEMP_VIEW`, :const:`SQLITE_CREATE_TRIGGER`, :const:`SQLITE_CREATE_VIEW`, :const:`SQLITE_CREATE_VTABLE`, :const:`SQLITE_DELETE`, :const:`SQLITE_DETACH`, :const:`SQLITE_DROP_INDEX`, :const:`SQLITE_DROP_TABLE`, :const:`SQLITE_DROP_TEMP_INDEX`, :const:`SQLITE_DROP_TEMP_TABLE`, :const:`SQLITE_DROP_TEMP_TRIGGER`, :const:`SQLITE_DROP_TEMP_VIEW`, :const:`SQLITE_DROP_TRIGGER`, :const:`SQLITE_DROP_VIEW`, :const:`SQLITE_DROP_VTABLE`, :const:`SQLITE_FUNCTION`, :const:`SQLITE_INSERT`, :const:`SQLITE_PRAGMA`, :const:`SQLITE_READ`, :const:`SQLITE_REINDEX`, :const:`SQLITE_SAVEPOINT`, :const:`SQLITE_SELECT`, :const:`SQLITE_TRANSACTION`, :const:`SQLITE_UPDATE`

.. data:: mapping_authorizer_return

   `Authorizer Return Codes <http://www.sqlite.org/c3ref/c_deny.html>`__

    :const:`SQLITE_DENY`, :const:`SQLITE_IGNORE`, :const:`SQLITE_OK`

.. data:: mapping_bestindex_constraints

   `Virtual Table Constraint Operator Codes <http://www.sqlite.org/c3ref/c_index_constraint_eq.html>`__

    :const:`SQLITE_INDEX_CONSTRAINT_EQ`, :const:`SQLITE_INDEX_CONSTRAINT_GE`, :const:`SQLITE_INDEX_CONSTRAINT_GT`, :const:`SQLITE_INDEX_CONSTRAINT_LE`, :const:`SQLITE_INDEX_CONSTRAINT_LT`, :const:`SQLITE_INDEX_CONSTRAINT_MATCH`

.. data:: mapping_config

   `Configuration Options <http://www.sqlite.org/c3ref/c_config_getmalloc.html>`__

    :const:`SQLITE_CONFIG_GETMALLOC`, :const:`SQLITE_CONFIG_GETMUTEX`, :const:`SQLITE_CONFIG_GETPCACHE`, :const:`SQLITE_CONFIG_HEAP`, :const:`SQLITE_CONFIG_LOG`, :const:`SQLITE_CONFIG_LOOKASIDE`, :const:`SQLITE_CONFIG_MALLOC`, :const:`SQLITE_CONFIG_MEMSTATUS`, :const:`SQLITE_CONFIG_MULTITHREAD`, :const:`SQLITE_CONFIG_MUTEX`, :const:`SQLITE_CONFIG_PAGECACHE`, :const:`SQLITE_CONFIG_PCACHE`, :const:`SQLITE_CONFIG_SCRATCH`, :const:`SQLITE_CONFIG_SERIALIZED`, :const:`SQLITE_CONFIG_SINGLETHREAD`

.. data:: mapping_db_config

   `Database Connection Configuration Options <http://www.sqlite.org/c3ref/c_dbconfig_enable_fkey.html>`__

    :const:`SQLITE_DBCONFIG_ENABLE_FKEY`, :const:`SQLITE_DBCONFIG_ENABLE_TRIGGER`, :const:`SQLITE_DBCONFIG_LOOKASIDE`

.. data:: mapping_db_status

   `Status Parameters for database connections <http://www.sqlite.org/c3ref/c_dbstatus_cache_used.html>`__

    :const:`SQLITE_DBSTATUS_CACHE_USED`, :const:`SQLITE_DBSTATUS_LOOKASIDE_HIT`, :const:`SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL`, :const:`SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE`, :const:`SQLITE_DBSTATUS_LOOKASIDE_USED`, :const:`SQLITE_DBSTATUS_MAX`, :const:`SQLITE_DBSTATUS_SCHEMA_USED`, :const:`SQLITE_DBSTATUS_STMT_USED`

.. data:: mapping_device_characteristics

   `Device Characteristics <http://www.sqlite.org/c3ref/c_iocap_atomic.html>`__

    :const:`SQLITE_IOCAP_ATOMIC`, :const:`SQLITE_IOCAP_ATOMIC16K`, :const:`SQLITE_IOCAP_ATOMIC1K`, :const:`SQLITE_IOCAP_ATOMIC2K`, :const:`SQLITE_IOCAP_ATOMIC32K`, :const:`SQLITE_IOCAP_ATOMIC4K`, :const:`SQLITE_IOCAP_ATOMIC512`, :const:`SQLITE_IOCAP_ATOMIC64K`, :const:`SQLITE_IOCAP_ATOMIC8K`, :const:`SQLITE_IOCAP_SAFE_APPEND`, :const:`SQLITE_IOCAP_SEQUENTIAL`, :const:`SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN`

.. data:: mapping_extended_result_codes

   `Extended Result Codes <http://www.sqlite.org/c3ref/c_busy_recovery.html>`__

    :const:`SQLITE_BUSY_RECOVERY`, :const:`SQLITE_CANTOPEN_NOTEMPDIR`, :const:`SQLITE_IOERR_ACCESS`, :const:`SQLITE_IOERR_BLOCKED`, :const:`SQLITE_IOERR_CHECKRESERVEDLOCK`, :const:`SQLITE_IOERR_CLOSE`, :const:`SQLITE_IOERR_DELETE`, :const:`SQLITE_IOERR_DIR_CLOSE`, :const:`SQLITE_IOERR_DIR_FSYNC`, :const:`SQLITE_IOERR_FSTAT`, :const:`SQLITE_IOERR_FSYNC`, :const:`SQLITE_IOERR_LOCK`, :const:`SQLITE_IOERR_NOMEM`, :const:`SQLITE_IOERR_RDLOCK`, :const:`SQLITE_IOERR_READ`, :const:`SQLITE_IOERR_SHMLOCK`, :const:`SQLITE_IOERR_SHMOPEN`, :const:`SQLITE_IOERR_SHMSIZE`, :const:`SQLITE_IOERR_SHORT_READ`, :const:`SQLITE_IOERR_TRUNCATE`, :const:`SQLITE_IOERR_UNLOCK`, :const:`SQLITE_IOERR_WRITE`, :const:`SQLITE_LOCKED_SHAREDCACHE`

.. data:: mapping_file_control

   `Standard File Control Opcodes <http://www.sqlite.org/c3ref/c_fcntl_chunk_size.html>`__

    :const:`SQLITE_FCNTL_CHUNK_SIZE`, :const:`SQLITE_FCNTL_FILE_POINTER`, :const:`SQLITE_FCNTL_LOCKSTATE`, :const:`SQLITE_FCNTL_SIZE_HINT`, :const:`SQLITE_FCNTL_SYNC_OMITTED`, :const:`SQLITE_GET_LOCKPROXYFILE`, :const:`SQLITE_LAST_ERRNO`, :const:`SQLITE_SET_LOCKPROXYFILE`

.. data:: mapping_limits

   `Run-Time Limit Categories <http://www.sqlite.org/c3ref/c_limit_attached.html>`__

    :const:`SQLITE_LIMIT_ATTACHED`, :const:`SQLITE_LIMIT_COLUMN`, :const:`SQLITE_LIMIT_COMPOUND_SELECT`, :const:`SQLITE_LIMIT_EXPR_DEPTH`, :const:`SQLITE_LIMIT_FUNCTION_ARG`, :const:`SQLITE_LIMIT_LENGTH`, :const:`SQLITE_LIMIT_LIKE_PATTERN_LENGTH`, :const:`SQLITE_LIMIT_SQL_LENGTH`, :const:`SQLITE_LIMIT_TRIGGER_DEPTH`, :const:`SQLITE_LIMIT_VARIABLE_NUMBER`, :const:`SQLITE_LIMIT_VDBE_OP`

.. data:: mapping_locking_level

   `File Locking Levels <http://www.sqlite.org/c3ref/c_lock_exclusive.html>`__

    :const:`SQLITE_LOCK_EXCLUSIVE`, :const:`SQLITE_LOCK_NONE`, :const:`SQLITE_LOCK_PENDING`, :const:`SQLITE_LOCK_RESERVED`, :const:`SQLITE_LOCK_SHARED`

.. data:: mapping_open_flags

   `Flags For File Open Operations <http://www.sqlite.org/c3ref/c_open_autoproxy.html>`__

    :const:`SQLITE_OPEN_AUTOPROXY`, :const:`SQLITE_OPEN_CREATE`, :const:`SQLITE_OPEN_DELETEONCLOSE`, :const:`SQLITE_OPEN_EXCLUSIVE`, :const:`SQLITE_OPEN_FULLMUTEX`, :const:`SQLITE_OPEN_MAIN_DB`, :const:`SQLITE_OPEN_MAIN_JOURNAL`, :const:`SQLITE_OPEN_MASTER_JOURNAL`, :const:`SQLITE_OPEN_NOMUTEX`, :const:`SQLITE_OPEN_PRIVATECACHE`, :const:`SQLITE_OPEN_READONLY`, :const:`SQLITE_OPEN_READWRITE`, :const:`SQLITE_OPEN_SHAREDCACHE`, :const:`SQLITE_OPEN_SUBJOURNAL`, :const:`SQLITE_OPEN_TEMP_DB`, :const:`SQLITE_OPEN_TEMP_JOURNAL`, :const:`SQLITE_OPEN_TRANSIENT_DB`, :const:`SQLITE_OPEN_WAL`

.. data:: mapping_result_codes

   `Result Codes <http://www.sqlite.org/c3ref/c_abort.html>`__

    :const:`SQLITE_ABORT`, :const:`SQLITE_AUTH`, :const:`SQLITE_BUSY`, :const:`SQLITE_CANTOPEN`, :const:`SQLITE_CONSTRAINT`, :const:`SQLITE_CORRUPT`, :const:`SQLITE_EMPTY`, :const:`SQLITE_ERROR`, :const:`SQLITE_FORMAT`, :const:`SQLITE_FULL`, :const:`SQLITE_INTERNAL`, :const:`SQLITE_INTERRUPT`, :const:`SQLITE_IOERR`, :const:`SQLITE_LOCKED`, :const:`SQLITE_MISMATCH`, :const:`SQLITE_MISUSE`, :const:`SQLITE_NOLFS`, :const:`SQLITE_NOMEM`, :const:`SQLITE_NOTADB`, :const:`SQLITE_NOTFOUND`, :const:`SQLITE_OK`, :const:`SQLITE_PERM`, :const:`SQLITE_PROTOCOL`, :const:`SQLITE_RANGE`, :const:`SQLITE_READONLY`, :const:`SQLITE_SCHEMA`, :const:`SQLITE_TOOBIG`

.. data:: mapping_status

   `Status Parameters <http://www.sqlite.org/c3ref/c_status_malloc_count.html>`__

    :const:`SQLITE_STATUS_MALLOC_COUNT`, :const:`SQLITE_STATUS_MALLOC_SIZE`, :const:`SQLITE_STATUS_MEMORY_USED`, :const:`SQLITE_STATUS_PAGECACHE_OVERFLOW`, :const:`SQLITE_STATUS_PAGECACHE_SIZE`, :const:`SQLITE_STATUS_PAGECACHE_USED`, :const:`SQLITE_STATUS_PARSER_STACK`, :const:`SQLITE_STATUS_SCRATCH_OVERFLOW`, :const:`SQLITE_STATUS_SCRATCH_SIZE`, :const:`SQLITE_STATUS_SCRATCH_USED`

.. data:: mapping_sync

   `Synchronization Type Flags <http://www.sqlite.org/c3ref/c_sync_dataonly.html>`__

    :const:`SQLITE_SYNC_DATAONLY`, :const:`SQLITE_SYNC_FULL`, :const:`SQLITE_SYNC_NORMAL`

.. data:: mapping_wal_checkpoint

   `Checkpoint operation parameters <http://www.sqlite.org/c3ref/c_checkpoint_full.html>`__

    :const:`SQLITE_CHECKPOINT_FULL`, :const:`SQLITE_CHECKPOINT_PASSIVE`, :const:`SQLITE_CHECKPOINT_RESTART`