Lines Matching full:database
162 ** CAPI3REF: Database Connection Handle {H12000} <S40200>
163 ** KEYWORDS: {database connection} {database connections}
165 ** Each open SQLite database is represented by a pointer to an instance of
211 ** CAPI3REF: Closing A Database Connection {H12010} <S30100><S40200>
219 ** [prepared statements] associated with a [database connection] if desired.
269 ** statements are evaluated and the database is not changed.
273 ** The sqlite3_exec() routine does nothing to the database that cannot be done
277 ** [database connection].
279 ** The database connection must not be closed while
294 sqlite3*, /* An open database */
315 #define SQLITE_ERROR 1 /* SQL error or missing database */
319 #define SQLITE_BUSY 5 /* The database file is locked */
320 #define SQLITE_LOCKED 6 /* A table in the database is locked */
322 #define SQLITE_READONLY 8 /* Attempt to write a readonly database */
325 #define SQLITE_CORRUPT 11 /* The database disk image is malformed */
327 #define SQLITE_FULL 13 /* Insertion failed because database is full */
328 #define SQLITE_CANTOPEN 14 /* Unable to open the database file */
329 #define SQLITE_PROTOCOL 15 /* NOT USED. Database lock protocol error */
330 #define SQLITE_EMPTY 16 /* Database is empty */
331 #define SQLITE_SCHEMA 17 /* The database schema changed */
338 #define SQLITE_FORMAT 24 /* Auxiliary database format error */
340 #define SQLITE_NOTADB 26 /* File opened that is not a database file */
357 ** on a per database connection basis using the
513 ** The xCheckReservedLock() method checks whether any database connection,
568 ** database corruption.
691 ** SQLITE_IOERR. Or the implementation might recognize that a database
708 ** for the main database file.
882 ** CAPI3REF: Configure database connections {H14200} <S20000>
886 ** changes to a [database connection]. The interface is similar to
888 ** [database connection] (specified in the first argument). The
890 ** the database connection is created using [sqlite3_open()],
895 ** aspect of the [database connection] is being configured.
982 ** mutexing on [database connection] and [prepared statement] objects.
984 ** [database connections] and [prepared statements]. But other mutexes
987 ** [database connection] at the same time. See the [threading mode]
993 ** mutexes on [database connection] and [prepared statement] objects.
996 ** to [database connections] and [prepared statements] so that the
997 ** application is free to use the same [database connection] or the
1038 ** parameter should be 6 times the size of the largest database page size.
1046 ** the database page cache with the default page cache implemenation.
1092 ** slots allocated to each database connection.</dd>
1140 ** [lookaside memory allocator] configuration for the [database connection].
1177 ** successful [INSERT] into the database from the [database connection]
1179 ** have ever occurred on that database connection, zero is returned.
1203 ** database connection while the [sqlite3_last_insert_rowid()]
1214 ** This function returns the number of database rows that were changed
1216 ** on the [database connection] specified by the first parameter.
1265 ** If a separate thread makes changes on the same database connection
1275 ** UPDATE or DELETE statements since the [database connection] was opened.
1299 ** If a separate thread makes changes on the same database connection
1308 ** This function causes any pending database operation to abort and
1315 ** thread that is currently running the database operation. But it
1316 ** is not safe to call this routine with a [database connection] that
1334 ** If the database connection closes while [sqlite3_interrupt()]
1371 ** an attempt is made to open a database table that another thread
1383 ** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned.
1385 ** is made to open the database for reading and the cycle repeats.
1407 ** already hold a RESERVED lock on the database file, but it needs
1409 ** pages into the database file without harm to concurrent
1420 ** [database connection]. Setting a new busy handler clears any
1425 ** database connection that invoked the busy handler. Any such actions
1431 ** A busy handler must not close the database connection
1450 ** [database connection] any any given moment. If another busy handler
1531 sqlite3 *db, /* An open database */
1764 ** [database connection], supplied in the first argument.
1801 ** try to execute malicious statements that damage the database. For
1803 ** SQL queries for evaluation by a database. But the application does
1805 ** database. An authorizer could then be put in place while the
1811 ** and limiting database size using the [max_page_count] [PRAGMA]
1814 ** Only a single authorizer can be in place on a database connection
1820 ** the database connection that invoked the authorizer callback.
1822 ** database connections for the meaning of "modify" in this paragraph.
1868 ** authorizer callback is the name of the database ("main", "temp",
1902 #define SQLITE_DETACH 25 /* Database Name NULL */
1903 #define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */
1953 ** the database connection that invoked the progress handler.
1955 ** database connections for the meaning of "modify" in this paragraph.
1964 ** CAPI3REF: Opening A New Database Connection {H12700} <S40200>
1966 ** These routines open an SQLite database file whose name is given by the
1969 ** order for sqlite3_open16(). A [database connection] handle is usually
1973 ** object. If the database is opened (and/or created) successfully, then
1978 ** The default encoding for the database will be UTF-8 if
1983 ** associated with the [database connection] handle should be released by
1988 ** over the new database connection. The flags parameter can take one of
1994 ** <dd>The database is opened in read-only mode. If the database does not
1998 ** <dd>The database is opened for reading and writing if possible, or reading
2000 ** case the database must already exist, otherwise an error is returned.</dd>
2003 ** <dd>The database is opened for reading and writing, and is creates it if
2013 ** If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
2016 ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
2020 ** If the filename is ":memory:", then a private, temporary in-memory database
2021 ** is created for the connection. This in-memory database will vanish when
2022 ** the database connection is closed. Future versions of SQLite might
2024 ** It is recommended that when a database filename actually does begin with
2029 ** on-disk database will be created. This private database will be
2030 ** automatically deleted as soon as the database connection is closed.
2034 ** the new database connection should use. If the fourth parameter is
2048 const char *filename, /* Database filename (UTF-8) */
2052 const void *filename, /* Database filename (UTF-16) */
2056 const char *filename, /* Database filename (UTF-8) */
2067 ** associated with a [database connection]. If a prior API call failed
2086 ** this, each thread can obtain exclusive use of the [database connection] D
2134 ** [database connection] whose limit is to be set or queried. The
2149 ** both their own internal database and also databases that are controlled
2157 ** interface to further control untrusted SQL. The size of the database
2232 ** The first argument, "db", is a [database connection] obtained from a
2274 ** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
2299 sqlite3 *db, /* Database handle */
2306 sqlite3 *db, /* Database handle */
2313 sqlite3 *db, /* Database handle */
2320 sqlite3 *db, /* Database handle */
2344 ** that can be stored in a database table. SQLite uses dynamic typing
2616 ** table in which database a result of a [SELECT] statement comes from.
2617 ** The name of the database or table or column can be returned as
2619 ** the database name, the _table_ routines return the table name, and
2626 ** database, table, and column.
2635 ** occurs. Otherwise, they return the name of the attached database, table
2675 ** For example, given the database schema:
2719 ** [SQLITE_BUSY] means that the database engine was unable to acquire the
2720 ** database locks it needs to do its job. If the statement is a [COMMIT]
2749 ** be the case that the same database connection is being used by two or
3038 ** The first parameter is the [database connection] to which the SQL
3039 ** function is to be added. If a single program uses more than one database
3041 ** each database connection.
3084 ** matches the database encoding is a better
3092 ** built-in functions in the same [database connection] with the same name.
3099 ** close the database connection nor finalize or reset the prepared
3267 ** CAPI3REF: Database Connection For Functions {H16250} <S60600><S20200>
3270 ** the pointer to the [database connection] (the 1st parameter)
3477 ** [database connection] specified as the first argument.
3512 ** collation creation functions or when the [database connection] is closed
3545 ** To avoid having to register all collation sequences before a database
3547 ** [database connection] to be called whenever an undefined collation
3558 ** sqlite3_collation_needed16(). The second argument is the database
3583 ** Specify the key for an encrypted database. This routine should be
3590 sqlite3 *db, /* Database to be rekeyed */
3595 ** Change the key on an open database. If the current database is not
3597 ** database is decrypted.
3603 sqlite3 *db, /* Database to be rekeyed */
3634 ** It is not safe to modify this variable once a [database connection]
3646 ** zero if the given database connection is or is not in autocommit mode,
3658 ** If another thread changes the autocommit status of the database
3667 ** CAPI3REF: Find The Database Handle Of A Prepared Statement {H13120} <S60600>
3669 ** The sqlite3_db_handle interface returns the [database connection] handle
3670 ** to which a [prepared statement] belongs. The [database connection]
3671 ** returned by sqlite3_db_handle is the same [database connection] that was the first argument
3683 ** pStmt associated with the [database connection] pDb. If pStmt is NULL
3685 ** associated with the database connection pDb. If no prepared statement
3688 ** The [database connection] pointer D in a call to
3689 ** [sqlite3_next_stmt(D,S)] must refer to an open database
3702 ** for the same database connection is overridden.
3706 ** for the same database connection is overridden.
3715 ** the database connection that invoked the callback. Any actions
3716 ** to modify the database connection must be deferred until after the
3720 ** database connections for the meaning of "modify" in this paragraph.
3728 ** automatically rolled back because the database connection is closed.
3744 ** with the [database connection] identified by the first argument
3747 ** for the same database connection is overridden.
3757 ** database and table name containing the affected row.
3765 ** the database connection that invoked the update hook. Any actions
3766 ** to modify the database connection must be deferred until after the
3769 ** database connections for the meaning of "modify" in this paragraph.
3787 ** This routine enables or disables the sharing of the database cache
3788 ** and schema data structures between [database connection | connections]
3789 ** to the same database. Sharing is enabled if the argument is true
3798 ** Existing database connections continue use the sharing mode
3823 ** held by the database library. {END} Memory used to cache database
3871 ** database table accessible using the [database connection] handle
3875 ** this function. The second parameter is either the name of the database
3876 ** (i.e. "main", "temp" or an attached database) containing the specified
3878 ** for the table using the same algorithm used by the database engine to
3921 ** This function may load one or more schemas from database files. If an
3924 ** in the [database connection] (to be retrieved using sqlite3_errmsg()).
3931 const char *zDbName, /* Database name or NULL */
3968 sqlite3 *db, /* Load the extension into this database connection */
3997 ** to all new [database connections]. {END}
4005 ** automatically invoked whenever a new [database connection]
4183 ** [database connection]. Module names must be registered before
4330 ** in row iRow, column zColumn, table zTable in database zDb;
4340 ** Note that the database name is not the filename that contains
4341 ** the database but rather the symbolic name of the database that
4342 ** is assigned when the database is connected using [ATTACH].
4343 ** For the main database file, the database name is "main".
4344 ** For TEMP tables, the database name is "temp".
4349 ** This function sets the [database connection] error code and message
4383 ** database connection is in [autocommit mode].
4737 ** CAPI3REF: Retrieve the mutex for a database connection {H17002} <H17000>
4740 ** serializes access to the [database connection] given in the argument
4748 ** CAPI3REF: Low-Level Control Of Database Files {H11300} <S30800>
4752 ** with a particular database identified by the second argument. {H11302} The
4753 ** name of the database is the name assigned to the database by the
4755 ** database. {H11303} To control the main database file, use the name "main"
4762 ** open database file, then SQLITE_ERROR is returned. {H11307} This error
4932 ** CAPI3REF: Database Connection Status {H17500} <S60200>
4936 ** about a single [database connection]. The first argument is the
4937 ** database connection object to be interrogated. The second argument
4952 ** CAPI3REF: Status Parameters for database connections {H17520} <H17500>
5039 ** from, or ready to be written to, the database file. By implementing a
5043 ** determine exactly which parts of a database file are cached and for
5061 ** be used to cache database pages read from a file stored on disk, or
5062 database. The cache implementation
5093 ** by writing their contents to the database file (a
5177 ** This API is used to overwrite the contents of one database with that
5183 ** Exclusive access is required to the destination database for the
5184 ** duration of the operation. However the source database is only
5187 ** performed on a live database without preventing other users from
5188 ** writing to the database for an extended period of time.
5204 ** The first two arguments passed to [sqlite3_backup_init()] are the database
5205 ** handle associated with the destination database and the database name
5206 ** used to attach the destination database to the handle. The database name
5207 ** is "main" for the main database, "temp" for the temporary database, or
5209 ** an attached database. The third and fourth arguments passed to
5210 ** sqlite3_backup_init() identify the [database connection]
5211 ** and database name used
5212 ** to access the source database. The values passed for the source and
5213 ** destination [database connection] parameters must not be the same.
5216 ** and an error code and error message written into the [database connection]
5238 ** As well as the case where the destination database file was opened for
5240 ** the destination is an in-memory database with a different page size
5241 ** from the source database.
5249 ** [database connection]
5250 ** is being used to write to the source database when sqlite3_backup_step()
5265 ** the source database file. This lock is released before the
5266 ** sqlite3_backup_step() call returns. Because the source database is not
5268 ** through the backup procedure. If the source database is modified by an
5269 ** external process or via a database connection other than the one being
5272 ** database is modified by the using the same database connection as is used
5273 ** by the backup operation, then the backup database is transparently
5283 ** destination database is rolled back. The [sqlite3_backup] object is invalid
5293 ** written to the destination [database connection].
5304 ** number of pages in the source database file, which may be queried by
5308 ** sqlite3_backup_step(). If the source database is modified during a backup
5310 ** pages that need to be updated or the size of the source database file
5313 ** <b>Concurrent Usage of Database Handles</b>
5315 ** The source [database connection] may be used by the application for other
5317 ** If SQLite is compiled and configured to support threadsafe database
5318 ** connections, then the source database connection may be used concurrently
5321 ** However, the application must guarantee that the destination database
5325 ** for this, if the application does use the destination [database connection]
5328 ** destination database connection while a backup is in progress might
5332 ** guarantee that the shared cache used by the destination database
5346 sqlite3 *pDest, /* Destination database handle */
5347 const char *zDestName, /* Destination database name */
5348 sqlite3 *pSource, /* Source database handle */
5349 const char *zSourceName /* Source database name */
5360 ** When running in shared-cache mode, a database operation may fail with
5371 ** Shared-cache locks are released when a database connection concludes
5376 ** identity of the database connection (the blocking connection) that
5428 ** related to the set of unblocked database connections.
5433 ** database waits for the callback to be issued before taking any further
