Lines Matching full:database
215 ** CAPI3REF: Database Connection Handle
216 ** KEYWORDS: {database connection} {database connections}
218 ** Each open SQLite database is represented by a pointer to an instance of
267 ** CAPI3REF: Closing A Database Connection
276 ** sqlite3_close() is called on a [database connection] that still has
309 ** in the context of the [database connection] passed in as its 1st
346 ** SQL comments, then no SQL statements are evaluated and the database
353 ** is a valid and open [database connection].
354 ** <li> The application must not close [database connection] specified by
361 sqlite3*, /* An open database */
382 #define SQLITE_ERROR 1 /* SQL error or missing database */
386 #define SQLITE_BUSY 5 /* The database file is locked */
387 #define SQLITE_LOCKED 6 /* A table in the database is locked */
389 #define SQLITE_READONLY 8 /* Attempt to write a readonly database */
392 #define SQLITE_CORRUPT 11 /* The database disk image is malformed */
394 #define SQLITE_FULL 13 /* Insertion failed because database is full */
395 #define SQLITE_CANTOPEN 14 /* Unable to open the database file */
396 #define SQLITE_PROTOCOL 15 /* Database lock protocol error */
397 #define SQLITE_EMPTY 16 /* Database is empty */
398 #define SQLITE_SCHEMA 17 /* The database schema changed */
405 #define SQLITE_FORMAT 24 /* Auxiliary database format error */
407 #define SQLITE_NOTADB 26 /* File opened that is not a database file */
424 ** on a per database connection basis using the
608 ** The xCheckReservedLock() method checks whether any database connection,
663 ** database corruption.
705 ** layer a hint of how large the database file will grow to be during the
707 ** is often close. The underlying VFS might choose to preallocate database
708 ** file space based on this hint in order to help writes to the database
712 ** extends and truncates the database file in chunks of a size specified
715 ** for the nominated database. Allocating database file space in large
816 ** SQLITE_IOERR. Or the implementation might recognize that a database
1001 ** single thread. All open [database connections] must be closed and all
1089 ** CAPI3REF: Configure database connections
1092 ** changes to a [database connection]. The interface is similar to
1094 ** [database connection] (specified in the first argument). The
1096 ** the database connection is created using [sqlite3_open()],
1101 ** aspect of the [database connection] is being configured.
1220 ** mutexing on [database connection] and [prepared statement] objects.
1222 ** [database connections] and [prepared statements]. But other mutexes
1225 ** [database connection] at the same time. ^If SQLite is compiled with
1235 ** mutexes on [database connection] and [prepared statement] objects.
1238 ** to [database connections] and [prepared statements] so that the
1239 ** application is free to use the same [database connection] or the
1291 ** times the database page size. ^If SQLite needs needs additional
1297 ** the database page cache with the default page cache implemenation.
1302 ** The sz argument should be the size of the largest database page
1359 ** [database connection]. The first argument is the
1361 ** slots allocated to each database connection.)^ ^(This option sets the
1415 ** CAPI3REF: Database Connection Configuration Options
1430 ** [lookaside memory allocator] configuration for the [database connection].
1442 ** configuration for a database connection can only be changed when that
1475 ** successful [INSERT] into the database from the [database connection]
1477 ** have ever occurred on that database connection, zero is returned.
1501 ** database connection while the [sqlite3_last_insert_rowid()]
1512 ** ^This function returns the number of database rows that were changed
1514 ** on the [database connection] specified by the first parameter.
1557 ** If a separate thread makes changes on the same database connection
1567 ** [UPDATE] or [DELETE] statements since the [database connection] was opened.
1583 ** If a separate thread makes changes on the same database connection
1592 ** ^This function causes any pending database operation to abort and
1599 ** thread that is currently running the database operation. But it
1600 ** is not safe to call this routine with a [database connection] that
1613 ** SQL statements on [database connection] D complete. ^Any new SQL statements
1623 ** If the database connection closes while [sqlite3_interrupt()]
1668 ** an attempt is made to open a database table that another thread
1680 ** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned.
1682 ** is made to open the database for reading and the cycle repeats.
1704 ** already hold a RESERVED lock on the database file, but it needs
1706 ** pages into the database file without harm to concurrent
1717 ** [database connection]. Setting a new busy handler clears any
1722 ** database connection that invoked the busy handler. Any such actions
1725 ** A busy handler must not close the database connection
1744 ** [database connection] any any given moment. If another busy handler
1823 sqlite3 *db, /* An open database */
2052 ** [database connection], supplied in the first argument.
2094 ** try to execute malicious statements that damage the database. For
2096 ** SQL queries for evaluation by a database. But the application does
2098 ** database. An authorizer could then be put in place while the
2104 ** and limiting database size using the [max_page_count] [PRAGMA]
2107 ** ^(Only a single authorizer can be in place on a database connection
2113 ** the database connection that invoked the authorizer callback.
2115 ** database connections for the meaning of "modify" in this paragraph.
2159 ** authorizer callback is the name of the database ("main", "temp",
2190 #define SQLITE_DETACH 25 /* Database Name NULL */
2191 #define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */
2235 ** database connection D. An example use for this
2244 ** [database connection]; setting a new progress handler cancels the
2254 ** the database connection that invoked the progress handler.
2256 ** database connections for the meaning of "modify" in this paragraph.
2262 ** CAPI3REF: Opening A New Database Connection
2264 ** ^These routines open an SQLite database file whose name is given by the
2267 ** order for sqlite3_open16(). ^(A [database connection] handle is usually
2271 ** object.)^ ^(If the database is opened (and/or created) successfully, then
2277 ** ^The default encoding for the database will be UTF-8 if
2282 ** associated with the [database connection] handle should be released by
2287 ** over the new database connection. ^(The flags parameter to
2295 ** <dd>The database is opened in read-only mode. If the database does not
2299 ** <dd>The database is opened for reading and writing if possible, or reading
2301 ** case the database must already exist, otherwise an error is returned.</dd>)^
2304 ** <dd>The database is opened for reading and writing, and is creates it if
2315 ** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
2318 ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
2321 ** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be
2324 ** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
2327 ** ^If the filename is ":memory:", then a private, temporary in-memory database
2328 ** is created for the connection. ^This in-memory database will vanish when
2329 ** the database connection is closed. Future versions of SQLite might
2331 ** It is recommended that when a database filename actually does begin with
2336 ** on-disk database will be created. ^This private database will be
2337 ** automatically deleted as soon as the database connection is closed.
2341 ** the new database connection should use. ^If the fourth parameter is
2351 const char *filename, /* Database filename (UTF-8) */
2355 const void *filename, /* Database filename (UTF-16) */
2359 const char *filename, /* Database filename (UTF-8) */
2370 ** associated with a [database connection]. If a prior API call failed
2389 ** this, each thread can obtain exclusive use of the [database connection] D
2434 ** [database connection] whose limit is to be set or queried. The
2454 ** both their own internal database and also databases that are controlled
2462 ** interface to further control untrusted SQL. The size of the database
2539 ** The first argument, "db", is a [database connection] obtained from a
2541 ** [sqlite3_open16()]. The database connection must not have been closed.
2584 ** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
2613 sqlite3 *db, /* Database handle */
2620 sqlite3 *db, /* Database handle */
2627 sqlite3 *db, /* Database handle */
2634 sqlite3 *db, /* Database handle */
2651 ** CAPI3REF: Determine If An SQL Statement Writes The Database
2669 ** that can be stored in a database table. SQLite uses dynamic typing
2922 ** ^These routines provide a means to determine the database, table, and
2925 ** ^The name of the database or table or column can be returned as
2927 ** the database name, the _table_ routines return the table name, and
2934 ** database, table, and column.
2944 ** occurs. ^Otherwise, they return the name of the attached database, table,
2980 ** ^(For example, given the database schema:
3021 ** ^[SQLITE_BUSY] means that the database engine was unable to acquire the
3022 ** database locks it needs to do its job. ^If the statement is a [COMMIT]
3051 ** be the case that the same database connection is being used by two or
3362 ** ^The first parameter is the [database connection] to which the SQL
3363 ** function is to be added. ^If an application uses more than one database
3365 ** to each database connection separately.
3409 ** overloaded or when the database connection closes.)^
3423 ** matches the database encoding is a better
3433 ** close the database connection nor finalize or reset the prepared
3614 ** CAPI3REF: Database Connection For Functions
3617 ** the pointer to the [database connection] (the 1st parameter)
3814 ** with the [database connection] specified as the first argument.
3876 ** [database connection] is closed using [sqlite3_close()].
3915 ** ^To avoid having to register all collation sequences before a database
3917 ** [database connection] to be invoked whenever an undefined collation
3928 ** sqlite3_collation_needed16(). The second argument is the database
3951 ** Specify the key for an encrypted database. This routine should be
3958 sqlite3 *db, /* Database to be rekeyed */
3963 ** Change the key on an open database. If the current database is not
3965 ** database is decrypted.
3971 sqlite3 *db, /* Database to be rekeyed */
3976 ** Specify the activation key for a SEE database. Unless
3986 ** Specify the activation key for a CEROD database. Unless
4025 ** if a [database connection] is being used at the same time in a separate
4049 ** zero if the given database connection is or is not in autocommit mode,
4061 ** If another thread changes the autocommit status of the database
4068 ** CAPI3REF: Find The Database Handle Of A Prepared Statement
4070 ** ^The sqlite3_db_handle interface returns the [database connection] handle
4071 ** to which a [prepared statement] belongs. ^The [database connection]
4072 ** returned by sqlite3_db_handle is the same [database connection]
4083 ** pStmt associated with the [database connection] pDb. ^If pStmt is NULL
4085 ** associated with the database connection pDb. ^If no prepared statement
4088 ** The [database connection] pointer D in a call to
4089 ** [sqlite3_next_stmt(D,S)] must refer to an open database
4100 ** for the same database connection is overridden.
4104 ** for the same database connection is overridden.
4111 ** on the same [database connection] D, or NULL for
4115 ** the database connection that invoked the callback. Any actions
4116 ** to modify the database connection must be deferred until after the
4120 ** database connections for the meaning of "modify" in this paragraph.
4134 ** automatically rolled back because the database connection is closed.
4145 ** with the [database connection] identified by the first argument
4148 ** for the same database connection is overridden.
4158 ** database and table name containing the affected row.
4173 ** the database connection that invoked the update hook. Any actions
4174 ** to modify the database connection must be deferred until after the
4177 ** database connections for the meaning of "modify" in this paragraph.
4181 ** on the same [database connection] D, or NULL for
4197 ** ^(This routine enables or disables the sharing of the database cache
4198 ** and schema data structures between [database connection | connections]
4199 ** to the same database. Sharing is enabled if the argument is true
4208 ** Existing database connections continue use the sharing mode
4227 ** held by the database library. Memory used to cache database
4303 ** database table accessible using the [database connection] handle
4307 ** this function. ^The second parameter is either the name of the database
4308 ** (i.e. "main", "temp", or an attached database) containing the specified
4310 ** for the table using the same algorithm used by the database engine to
4353 ** ^(This function may load one or more schemas from database files. If an
4356 ** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^
4363 const char *zDbName, /* Database name or NULL */
4399 sqlite3 *db, /* Load the extension into this database connection */
4424 ** each new [database connection] that is created. The idea here is that
4426 ** that is to be automatically loaded into all new database connections.
4451 ** will be called more than once for each database connection that is opened.
4494 ** module or until the [database connection] closes. The content
4496 ** any database connection.
4630 ** ^The module name is registered on the [database connection] specified
4764 ** in row iRow, column zColumn, table zTable in database zDb;
4777 ** ^Note that the database name is not the filename that contains
4778 ** the database but rather the symbolic name of the database that
4779 ** appears after the AS keyword when the database is connected using [ATTACH].
4780 ** ^For the main database file, the database name is "main".
4781 ** ^For TEMP tables, the database name is "temp".
4786 ** ^This function sets the [database connection] error code and message
4830 ** to a different row of the same database table. ^The new row is identified
4832 ** changed. ^The database, table and column on which the blob handle is open
4846 ** ^This function sets the database handle error code and message.
4857 ** database connection is in [autocommit mode].
5241 ** CAPI3REF: Retrieve the mutex for a database connection
5244 ** serializes access to the [database connection] given in the argument
5252 ** CAPI3REF: Low-Level Control Of Database Files
5256 ** with a particular database identified by the second argument. ^The
5257 ** name of the database is "main" for the main database or "temp" for the
5258 ** TEMP database, or the name that appears after the AS keyword for
5261 ** main database file.
5274 ** open database file, then SQLITE_ERROR is returned. ^This error
5455 ** CAPI3REF: Database Connection Status
5458 ** about a single [database connection]. ^The first argument is the
5459 ** database connection object to be interrogated. ^The second argument
5479 ** CAPI3REF: Status Parameters for database connections
5497 ** memory used by all pager caches associated with the database connection.)^
5505 ** schema memory is shared with other database connections due to
5512 ** the database connection.)^
5607 ** determine exactly which parts of a database file are cached and for
5644 ** SQLite will typically create one cache instance for each open database file,
5648 ** will the page size of the database file that is to be cached plus an
5651 ** database page on disk. The value of R depends
5655 ** be used to cache database pages of a file stored on disk, or
5656 ** false if it is used for an in-memory database. The cache implementation
5763 ** The backup API copies the content of one database into another.
5769 ** ^Exclusive access is required to the destination database for the
5770 ** duration of the operation. ^However the source database is only
5773 ** performed on a live source database without preventing other users from
5774 ** reading or writing to the source database while the backup is underway.
5791 ** [database connection] associated with the destination database
5792 ** and the database name, respectively.
5793 ** ^The database name is "main" for the main database, "temp" for the
5794 ** temporary database, or the name specified after the AS keyword in
5795 ** an [ATTACH] statement for an attached database.
5797 ** sqlite3_backup_init(D,N,S,M) identify the [database connection]
5798 ** and database name of the source database, respectively.
5799 ** ^The source and destination [database connections] (parameters S and D)
5805 ** destination [database connection] D.
5832 ** <li> the destination database was opened read-only, or
5833 ** <li> the destination database is using write-ahead-log journaling
5835 ** <li> The destination database is an in-memory database and the
5845 ** [database connection]
5846 ** is being used to write to the source database when sqlite3_backup_step()
5860 ** sqlite3_backup_step() obtains a [shared lock] on the source database that
5862 ** ^Because the source database is not locked between calls to
5863 ** sqlite3_backup_step(), the source database may be modified mid-way
5864 ** through the backup process. ^If the source database is modified by an
5865 ** external process or via a database connection other than the one being
5868 ** database is modified by the using the same database connection as is used
5869 ** by the backup operation, then the backup database is automatically
5880 ** active write-transaction on the destination database is rolled back.
5899 ** up and the total number of pages in the source database file.
5904 ** sqlite3_backup_step(). ^If the source database is modified during a backup
5906 ** pages that need to be updated or the size of the source database file
5909 ** <b>Concurrent Usage of Database Handles</b>
5911 ** ^The source [database connection] may be used by the application for other
5913 ** ^If SQLite is compiled and configured to support threadsafe database
5914 ** connections, then the source database connection may be used concurrently
5918 ** [database connection] is not passed to any other API (by any thread) after
5921 ** if the application incorrectly accesses the destination [database connection]
5923 ** nevertheless. Use of the destination database connection while a
5927 ** guarantee that the shared cache used by the destination database
5941 sqlite3 *pDest, /* Destination database handle */
5942 const char *zDestName, /* Destination database name */
5943 sqlite3 *pSource, /* Source database handle */
5944 const char *zSourceName /* Source database name */
5954 ** ^When running in shared-cache mode, a database operation may fail with
5965 ** ^Shared-cache locks are released when a database connection concludes
5970 ** identity of the database connection (the blocking connection) that
6022 ** related to the set of unblocked database connections.
6027 ** database waits for the callback to be issued before taking any further
6109 ** will be invoked each time a database connection commits data to a
6114 ** the associated write-lock on the database released, so the implementation
6115 ** may read, write or [checkpoint] the database as required.
6119 ** registering the callback. ^The second is a copy of the database handle.
6120 ** ^The third parameter is the name of the database that was written to -
6121 ** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter
6133 ** A single database handle may have at most a single write-ahead log callback
6150 ** [sqlite3_wal_hook()] that causes any database on [database connection] D
6165 ** ^Every new [database connection] defaults to having the auto-checkpoint
6173 ** CAPI3REF: Checkpoint a database
6175 ** ^The [sqlite3_wal_checkpoint(D,X)] interface causes database named X
6176 ** on [database connection] D to be [checkpointed]. ^If X is NULL or an
6178 ** connection D. ^If the database connection D is not in
