Open flag: Flag for openDatabase(String, byte[], SQLiteCipherSpec, SQLiteDatabase.CursorFactory, int, DatabaseErrorHandler) to open the database with I/O trace enabled. This causes database to log I/O operations to file.

See Also

• enableWriteAheadLogging()

Absolute max value that can be set by setMaxSqlCacheSize(int) . Each prepared-statement is between 1K - 6K, depending on the complexity of the SQL statement & schema. A large SQL cache may use a significant amount of memory.

Open flag: Flag for openDatabase(String, byte[], SQLiteCipherSpec, SQLiteDatabase.CursorFactory, int, DatabaseErrorHandler) that indicates no backup for database files is done when corruption is detected.

Open flag: Flag for openDatabase(String, byte[], SQLiteCipherSpec, SQLiteDatabase.CursorFactory, int, DatabaseErrorHandler) to open the database without support for localized collators.

This causes the collator LOCALIZED not to be created. You must be consistent when using this flag to use the setting the database was created with. If this is set, setLocale(Locale) will do nothing.

Open flag: Flag for openDatabase(String, byte[], SQLiteCipherSpec, SQLiteDatabase.CursorFactory, int, DatabaseErrorHandler) to open the database for reading only. This is the only reliable way to open a database if the disk may be full.

Open flag: Flag for openDatabase(String, byte[], SQLiteCipherSpec, SQLiteDatabase.CursorFactory, int, DatabaseErrorHandler) to open the database for reading and writing. If the disk is full, this may fail even before you actually write anything.

Note that the value of this flag is 0, so it is the default.

Maximum Length Of A LIKE Or GLOB Pattern The pattern matching algorithm used in the default LIKE and GLOB implementation of SQLite can exhibit O(N^2) performance (where N is the number of characters in the pattern) for certain pathological cases. To avoid denial-of-service attacks the length of the LIKE or GLOB pattern is limited to SQLITE_MAX_LIKE_PATTERN_LENGTH bytes. The default value of this limit is 50000. A modern workstation can evaluate even a pathological LIKE or GLOB pattern of 50000 bytes relatively quickly. The denial of service problem only comes into play when the pattern length gets into millions of bytes. Nevertheless, since most useful LIKE or GLOB patterns are at most a few dozen bytes in length, paranoid application developers may want to reduce this parameter to something in the range of a few hundred if they know that external users are able to generate arbitrary patterns. Transactions can be nested. When the outer transaction is ended all of the work done in that transaction and all of the nested transactions will be committed or rolled back. The changes will be rolled back if any transaction is ended without being marked as clean (by calling setTransactionSuccessful). Otherwise they will be committed.

Here is the standard idiom for transactions: db.beginTransaction(); try { db.setTransactionSuccessful(); } finally { db.endTransaction();

Begins a transaction in IMMEDIATE mode. Transactions can be nested. When the outer transaction is ended all of the work done in that transaction and all of the nested transactions will be committed or rolled back. The changes will be rolled back if any transaction is ended without being marked as clean (by calling setTransactionSuccessful). Otherwise they will be committed. Here is the standard idiom for transactions: db.beginTransactionNonExclusive(); try { db.setTransactionSuccessful(); } finally { db.endTransaction(); Transactions can be nested. When the outer transaction is ended all of the work done in that transaction and all of the nested transactions will be committed or rolled back. The changes will be rolled back if any transaction is ended without being marked as clean (by calling setTransactionSuccessful). Otherwise they will be committed.

Here is the standard idiom for transactions: db.beginTransactionWithListener(listener); try { db.setTransactionSuccessful(); } finally { db.endTransaction();

Parameters

transactionListener listener that should be notified when the transaction begins, commits, or is rolled back, either explicitly or by a call to yieldIfContendedSafely() .

Begins a transaction in IMMEDIATE mode. Transactions can be nested. When the outer transaction is ended all of the work done in that transaction and all of the nested transactions will be committed or rolled back. The changes will be rolled back if any transaction is ended without being marked as clean (by calling setTransactionSuccessful). Otherwise they will be committed. Here is the standard idiom for transactions: db.beginTransactionWithListenerNonExclusive(listener); try { db.setTransactionSuccessful(); } finally { db.endTransaction();

Parameters

transactionListener listener that should be notified when the transaction begins, commits, or is rolled back, either explicitly or by a call to yieldIfContendedSafely() .

Compiles an SQL statement into a reusable pre-compiled statement object. The parameters are identical to execSQL(String) . You may put ?s in the statement and fill in those values with bindString(int, String) and bindLong(int, long) each time you want to run the statement. Statements may not return result sets larger than 1x1. No two threads should be using the same SQLiteStatement at the same time.

Parameters

The raw SQL statement, may contain ? for unknown values to be bound later.

Create a memory backed SQLite database. Its contents will be destroyed when the database is closed.

Sets the locale of the database to the the system's current locale. Call setLocale(Locale) if you would like something else.

Parameters

factory an optional factory class that is called to instantiate a cursor when query is called whereClause the optional WHERE clause to apply when deleting. Passing null will delete all rows. whereArgs You may include ?s in the where clause, which will be replaced by the values from whereArgs. The values will be bound as Strings.

Returns

• the number of rows affected if a whereClause is passed in, 0 otherwise. To remove all rows and get a count pass "1" as the whereClause.

  Deletes a database including its journal file and other auxiliary files that may have been created by the database engine.

  Parameters

  The database file path. IllegalStateException if there are transactions in progress at the time this method is called. WAL mode can only be changed when there are no transactions in progress.

  This method enables parallel execution of queries from multiple threads on the same database. It does this by opening multiple connections to the database and using a different database connection for each query. The database journal mode is also changed to enable writes to proceed concurrently with reads. When write-ahead logging is not enabled (the default), it is not possible for reads and writes to occur on the database at the same time. Before modifying the database, the writer implicitly acquires an exclusive lock on the database which prevents readers from accessing the database until the write is completed. In contrast, when write-ahead logging is enabled (by calling this method), write operations occur in a separate log file which allows reads to proceed concurrently. While a write is in progress, readers on other threads will perceive the state of the database as it was before the write began. When the write completes, readers on other threads will then perceive the new state of the database. It is a good idea to enable write-ahead logging whenever a database will be concurrently accessed and modified by multiple threads at the same time. However, write-ahead logging uses significantly more memory than ordinary journaling because there are multiple connections to the same database. So if a database will only be used by a single thread, or if optimizing concurrency is not very important, then write-ahead logging should be disabled. After calling this method, execution of queries in parallel is enabled as long as the database remains open. To disable execution of queries in parallel, either call disableWriteAheadLogging() or close the database and reopen it. The maximum number of connections used to execute queries in parallel is dependent upon the device memory and possibly other properties. If a query is part of a transaction, then it is executed on the same database handle the transaction was begun. Writers should use beginTransactionNonExclusive() or beginTransactionWithListenerNonExclusive(SQLiteTransactionListener) to start a transaction. Non-exclusive mode allows database file to be in readable by other threads executing queries. If the database has any attached databases, then execution of queries in parallel is NOT possible. Likewise, write-ahead logging is not supported for read-only databases or memory databases. In such cases, enableWriteAheadLogging() returns false. The best way to enable write-ahead logging is to pass the ENABLE_WRITE_AHEAD_LOGGING flag to openDatabase(String, byte[], SQLiteCipherSpec, SQLiteDatabase.CursorFactory, int, DatabaseErrorHandler) . This is more efficient than calling enableWriteAheadLogging() . SQLiteDatabase db = SQLiteDatabase.openDatabase("db_filename", cursorFactory, SQLiteDatabase.CREATE_IF_NECESSARY | SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING, myDatabaseErrorHandler); db.enableWriteAheadLogging(); Another way to enable write-ahead logging is to call enableWriteAheadLogging() after opening the database. SQLiteDatabase db = SQLiteDatabase.openDatabase("db_filename", cursorFactory, SQLiteDatabase.CREATE_IF_NECESSARY, myDatabaseErrorHandler); db.enableWriteAheadLogging(); See also SQLite Write-Ahead Logging for more details about how write-ahead logging works.

  Returns

  • True if write-ahead logging is enabled.

  Throws

  IllegalStateException if there are transactions in progress at the time this method is called. WAL mode can only be changed when there are no transactions in progress.

  End a transaction. See beginTransaction for notes about how to use this and when transactions are committed and rolled back.

  Execute a single SQL statement that is NOT a SELECT or any other SQL statement that returns data. It has no means to return any data (such as the number of affected rows). Instead, you're encouraged to use insert(String, String, ContentValues) , update(String, ContentValues, String, String[]) , et al, when possible. When using enableWriteAheadLogging() , journal_mode is automatically managed by this class. So, do not set journal_mode using "PRAGMA journal_mode' " statement if your app is using enableWriteAheadLogging()

  Parameters

  the SQL statement to be executed. Multiple statements separated by semicolons are not supported.

  Execute a single SQL statement that is NOT a SELECT/INSERT/UPDATE/DELETE. For INSERT statements, use any of the following instead.

• insert(String, String, ContentValues)
• insertOrThrow(String, String, ContentValues)
• insertWithOnConflict(String, String, ContentValues, int)
For UPDATE statements, use any of the following instead.
• update(String, ContentValues, String, String[])
• updateWithOnConflict(String, ContentValues, String, String[], int)
For DELETE statements, use any of the following instead.
• delete(String, String, String[])
For example, the following are good candidates for using this method:
• ALTER TABLE
• CREATE or DROP table / trigger / view / index / virtual table
• REINDEX
• RELEASE
• SAVEPOINT
• PRAGMA that returns no data
When using enableWriteAheadLogging() , journal_mode is automatically managed by this class. So, do not set journal_mode using "PRAGMA journal_mode' " statement if your app is using enableWriteAheadLogging()

Parameters

the SQL statement to be executed. Multiple statements separated by semicolons are not supported. bindArgs only byte[], String, Long and Double are supported in bindArgs.

Returns list of full pathnames of all attached databases including the main database by executing 'pragma database_list' on the database.

Returns

• ArrayList of pairs of (database name, database file path) or null if the database is not open. This method is deprecated.
  This method no longer serves any useful purpose and has been deprecated.

  Deprecated.

  nullColumnHack optional; may be null . SQL doesn't allow inserting a completely empty row without naming at least one column name. If your provided values is empty, no column names are known and an empty row can't be inserted. If not set to null, the nullColumnHack parameter provides the name of nullable column name to explicitly insert a NULL into in the case where your values is empty. values this map contains the initial column values for the row. The keys should be the column names and the values the column values nullColumnHack optional; may be null . SQL doesn't allow inserting a completely empty row without naming at least one column name. If your provided values is empty, no column names are known and an empty row can't be inserted. If not set to null, the nullColumnHack parameter provides the name of nullable column name to explicitly insert a NULL into in the case where your values is empty. values this map contains the initial column values for the row. The keys should be the column names and the values the column values nullColumnHack optional; may be null . SQL doesn't allow inserting a completely empty row without naming at least one column name. If your provided initialValues is empty, no column names are known and an empty row can't be inserted. If not set to null, the nullColumnHack parameter provides the name of nullable column name to explicitly insert a NULL into in the case where your initialValues is empty. initialValues this map contains the initial column values for the row. The keys should be the column names and the values the column values conflictAlgorithm for insert conflict resolver

  Returns

  • the row ID of the newly inserted row OR the primary key of the existing row if the input param 'conflictAlgorithm' = CONFLICT_IGNORE OR -1 if any error

    Runs 'pragma integrity_check' on the given database (and all the attached databases) and returns true if the given database (and all its attached databases) pass integrity_check, false otherwise. If the result is false, then this method logs the errors reported by the integrity_check command execution. Note that 'pragma integrity_check' on a database can take a long time.

    Returns

    • true if the given database (and all its attached databases) pass integrity_check, false otherwise.

      Returns true if the current thread is holding an active connection to the database. The name of this method comes from a time when having an active connection to the database meant that the thread was holding an actual lock on the database. Nowadays, there is no longer a true "database lock" although threads may block if they cannot acquire a database connection to perform a particular operation.

      Returns

      • True if the current thread is holding an active connection to the database.

        Always returns false. There is no longer the concept of a database lock, so this method always returns false.

        Returns

        • False.

        This method is deprecated.
        This method no longer serves any useful purpose and has been deprecated.

        Mark this table as syncable. When an update occurs in this table the _sync_dirty field will be set to ensure proper syncing operation.

        Parameters

        table the table to mark as syncable deletedTable The deleted table that corresponds to the syncable table This method is deprecated.
        This method no longer serves any useful purpose and has been deprecated.

        Mark this table as syncable, with the _sync_dirty residing in another table. When an update occurs in this table the _sync_dirty field of the row in updateTable with the _id in foreignKey will be set to ensure proper syncing operation.

        Parameters

        table an update on this table will trigger a sync time removal foreignKey this is the column in table whose value is an _id in updateTable updateTable this is the table that will have its _sync_dirty

        Returns true if the new version code is greater than the current database version.

        Parameters

        newVersion The new version code.

        Open the database according to the flags OPEN_READWRITE OPEN_READONLY CREATE_IF_NECESSARY and/or NO_LOCALIZED_COLLATORS .

        Sets the locale of the database to the the system's current locale. Call setLocale(Locale) if you would like something else.

        Accepts input param: a concrete instance of DatabaseErrorHandler to be used to handle corruption when sqlite reports database corruption.

        Parameters

        to database file to open and/or create password password to the encrypted database, or null for plain-text database cipher cipher description, or null for default settings factory an optional factory class that is called to instantiate a cursor when query is called, or null for default flags to control database access mode errorHandler the DatabaseErrorHandler obj to be used to handle corruption when sqlite reports database corruption

        Open the database according to the flags OPEN_READWRITE OPEN_READONLY CREATE_IF_NECESSARY and/or NO_LOCALIZED_COLLATORS .

        Sets the locale of the database to the the system's current locale. Call setLocale(Locale) if you would like something else.

        Accepts input param: a concrete instance of DatabaseErrorHandler to be used to handle corruption when sqlite reports database corruption.

        Parameters

        to database file to open and/or create factory an optional factory class that is called to instantiate a cursor when query is called, or null for default flags to control database access mode errorHandler the DatabaseErrorHandler obj to be used to handle corruption when sqlite reports database corruption poolSize size of the connection pool to the database, 0 for default size

        Open the database according to the flags OPEN_READWRITE OPEN_READONLY CREATE_IF_NECESSARY and/or NO_LOCALIZED_COLLATORS .

        Sets the locale of the database to the the system's current locale. Call setLocale(Locale) if you would like something else.

        Accepts input param: a concrete instance of DatabaseErrorHandler to be used to handle corruption when sqlite reports database corruption.

        Parameters

        to database file to open and/or create password password to the encrypted database, or null for plain-text database cipher cipher description, or null for default settings factory an optional factory class that is called to instantiate a cursor when query is called, or null for default flags to control database access mode errorHandler the DatabaseErrorHandler obj to be used to handle corruption when sqlite reports database corruption poolSize size of the connection pool to the database, 0 for default size

        Open the database according to the flags OPEN_READWRITE OPEN_READONLY CREATE_IF_NECESSARY and/or NO_LOCALIZED_COLLATORS .

        Sets the locale of the database to the the system's current locale. Call setLocale(Locale) if you would like something else.

        Accepts input param: a concrete instance of DatabaseErrorHandler to be used to handle corruption when sqlite reports database corruption.

        Parameters

        to database file to open and/or create factory an optional factory class that is called to instantiate a cursor when query is called, or null for default flags to control database access mode errorHandler the DatabaseErrorHandler obj to be used to handle corruption when sqlite reports database corruption

        Open the database according to the flags OPEN_READWRITE OPEN_READONLY CREATE_IF_NECESSARY and/or NO_LOCALIZED_COLLATORS .

        Sets the locale of the database to the the system's current locale. Call setLocale(Locale) if you would like something else.

        Parameters

        to database file to open and/or create factory an optional factory class that is called to instantiate a cursor when query is called, or null for default flags to control database access mode columns A list of which columns to return. Passing null will return all columns, which is discouraged to prevent reading data from storage that isn't going to be used. selection A filter declaring which rows to return, formatted as an SQL WHERE clause (excluding the WHERE itself). Passing null will return all rows for the given table. selectionArgs You may include ?s in selection, which will be replaced by the values from selectionArgs, in order that they appear in the selection. The values will be bound as Strings. groupBy A filter declaring how to group rows, formatted as an SQL GROUP BY clause (excluding the GROUP BY itself). Passing null will cause the rows to not be grouped. having A filter declare which row groups to include in the cursor, if row grouping is being used, formatted as an SQL HAVING clause (excluding the HAVING itself). Passing null will cause all row groups to be included, and is required when row grouping is not being used. orderBy How to order the rows, formatted as an SQL ORDER BY clause (excluding the ORDER BY itself). Passing null will use the default sort order, which may be unordered. limit Limits the number of rows returned by the query, formatted as LIMIT clause. Passing null denotes no LIMIT clause.

        Returns

        • A Cursor object, which is positioned before the first entry. Note that Cursor s are not synchronized, see the documentation for more details.

        See Also

        • Cursor
        columns A list of which columns to return. Passing null will return all columns, which is discouraged to prevent reading data from storage that isn't going to be used. selection A filter declaring which rows to return, formatted as an SQL WHERE clause (excluding the WHERE itself). Passing null will return all rows for the given table. selectionArgs You may include ?s in selection, which will be replaced by the values from selectionArgs, in order that they appear in the selection. The values will be bound as Strings. groupBy A filter declaring how to group rows, formatted as an SQL GROUP BY clause (excluding the GROUP BY itself). Passing null will cause the rows to not be grouped. having A filter declare which row groups to include in the cursor, if row grouping is being used, formatted as an SQL HAVING clause (excluding the HAVING itself). Passing null will cause all row groups to be included, and is required when row grouping is not being used. orderBy How to order the rows, formatted as an SQL ORDER BY clause (excluding the ORDER BY itself). Passing null will use the default sort order, which may be unordered. limit Limits the number of rows returned by the query, formatted as LIMIT clause. Passing null denotes no LIMIT clause. cancellationSignal A signal to cancel the operation in progress, or null if none. If the operation is canceled, then OperationCanceledException will be thrown when the query is executed.

        Returns

        • A Cursor object, which is positioned before the first entry. Note that Cursor s are not synchronized, see the documentation for more details.

        See Also

        • Cursor
        columns A list of which columns to return. Passing null will return all columns, which is discouraged to prevent reading data from storage that isn't going to be used. selection A filter declaring which rows to return, formatted as an SQL WHERE clause (excluding the WHERE itself). Passing null will return all rows for the given table. selectionArgs You may include ?s in selection, which will be replaced by the values from selectionArgs, in order that they appear in the selection. The values will be bound as Strings. groupBy A filter declaring how to group rows, formatted as an SQL GROUP BY clause (excluding the GROUP BY itself). Passing null will cause the rows to not be grouped. having A filter declare which row groups to include in the cursor, if row grouping is being used, formatted as an SQL HAVING clause (excluding the HAVING itself). Passing null will cause all row groups to be included, and is required when row grouping is not being used. orderBy How to order the rows, formatted as an SQL ORDER BY clause (excluding the ORDER BY itself). Passing null will use the default sort order, which may be unordered. limit Limits the number of rows returned by the query, formatted as LIMIT clause. Passing null denotes no LIMIT clause.

        Returns

        • A Cursor object, which is positioned before the first entry. Note that Cursor s are not synchronized, see the documentation for more details.

        See Also

        • Cursor
        columns A list of which columns to return. Passing null will return all columns, which is discouraged to prevent reading data from storage that isn't going to be used. selection A filter declaring which rows to return, formatted as an SQL WHERE clause (excluding the WHERE itself). Passing null will return all rows for the given table. selectionArgs You may include ?s in selection, which will be replaced by the values from selectionArgs, in order that they appear in the selection. The values will be bound as Strings. groupBy A filter declaring how to group rows, formatted as an SQL GROUP BY clause (excluding the GROUP BY itself). Passing null will cause the rows to not be grouped. having A filter declare which row groups to include in the cursor, if row grouping is being used, formatted as an SQL HAVING clause (excluding the HAVING itself). Passing null will cause all row groups to be included, and is required when row grouping is not being used. orderBy How to order the rows, formatted as an SQL ORDER BY clause (excluding the ORDER BY itself). Passing null will use the default sort order, which may be unordered.

        Returns

        • A Cursor object, which is positioned before the first entry. Note that Cursor s are not synchronized, see the documentation for more details.

        See Also

        • Cursor
        columns A list of which columns to return. Passing null will return all columns, which is discouraged to prevent reading data from storage that isn't going to be used. selection A filter declaring which rows to return, formatted as an SQL WHERE clause (excluding the WHERE itself). Passing null will return all rows for the given table. selectionArgs You may include ?s in selection, which will be replaced by the values from selectionArgs, in order that they appear in the selection. The values will be bound as Strings. groupBy A filter declaring how to group rows, formatted as an SQL GROUP BY clause (excluding the GROUP BY itself). Passing null will cause the rows to not be grouped. orderBy How to order the rows, formatteA filter declare which row groups to include in the cursor, if row grouping is being used, formatted as an SQL HAVING clause (excluding the HAVING itself). Passing null will cause all row groups to be included, and is required when row grouping is not being used.d as an SQL ORDER BY clause (excluding the ORDER BY itself). Passing null will use the default sort order, which may be unordered. limit Limits the number of rows returned by the query, formatted as LIMIT clause. Passing null denotes no LIMIT clause.

        Returns

        • A Cursor object, which is positioned before the first entry. Note that Cursor s are not synchronized, see the documentation for more details.

        See Also

        • Cursor
        columns A list of which columns to return. Passing null will return all columns, which is discouraged to prevent reading data from storage that isn't going to be used. selection A filter declaring which rows to return, formatted as an SQL WHERE clause (excluding the WHERE itself). Passing null will return all rows for the given table. selectionArgs You may include ?s in selection, which will be replaced by the values from selectionArgs, in order that they appear in the selection. The values will be bound as Strings. groupBy A filter declaring how to group rows, formatted as an SQL GROUP BY clause (excluding the GROUP BY itself). Passing null will cause the rows to not be grouped. having A filter declare which row groups to include in the cursor, if row grouping is being used, formatted as an SQL HAVING clause (excluding the HAVING itself). Passing null will cause all row groups to be included, and is required when row grouping is not being used. orderBy How to order the rows, formatted as an SQL ORDER BY clause (excluding the ORDER BY itself). Passing null will use the default sort order, which may be unordered. limit Limits the number of rows returned by the query, formatted as LIMIT clause. Passing null denotes no LIMIT clause. cancellationSignal A signal to cancel the operation in progress, or null if none. If the operation is canceled, then OperationCanceledException will be thrown when the query is executed.

        Returns

        • A Cursor object, which is positioned before the first entry. Note that Cursor s are not synchronized, see the documentation for more details.

        See Also

        • Cursor
        selectionArgs You may include ?s in where clause in the query, which will be replaced by the values from selectionArgs. The values will be bound as Strings. cancellationSignal A signal to cancel the operation in progress, or null if none. If the operation is canceled, then OperationCanceledException will be thrown when the query is executed. selectionArgs You may include ?s in where clause in the query, which will be replaced by the values from selectionArgs. The values will be bound as Strings. selectionArgs You may include ?s in where clause in the query, which will be replaced by the values from selectionArgs. The values will be bound as Strings. editTable the name of the first table, which is editable cancellationSignal A signal to cancel the operation in progress, or null if none. If the operation is canceled, then OperationCanceledException will be thrown when the query is executed. selectionArgs You may include ?s in where clause in the query, which will be replaced by the values from selectionArgs. The values will be bound as Strings. editTable the name of the first table, which is editable

        Attempts to release memory that SQLite holds but does not require to operate properly. Typically this memory will come from the page cache.

        Returns

        • the number of bytes actually released nullColumnHack optional; may be null . SQL doesn't allow inserting a completely empty row without naming at least one column name. If your provided initialValues is empty, no column names are known and an empty row can't be inserted. If not set to null, the nullColumnHack parameter provides the name of nullable column name to explicitly insert a NULL into in the case where your initialValues is empty. initialValues this map contains the initial column values for the row. nullColumnHack optional; may be null . SQL doesn't allow inserting a completely empty row without naming at least one column name. If your provided initialValues is empty, no column names are known and an empty row can't be inserted. If not set to null, the nullColumnHack parameter provides the name of nullable column name to explicitly insert a NULL into in the case where your initialValues is empty. initialValues this map contains the initial column values for the row. The key

          Sets whether foreign key constraints are enabled for the database. By default, foreign key constraints are not enforced by the database. This method allows an application to enable foreign key constraints. It must be called each time the database is opened to ensure that foreign key constraints are enabled for the session. A good time to call this method is right after calling openOrCreateDatabase(File, byte[], SQLiteCipherSpec, SQLiteDatabase.CursorFactory, DatabaseErrorHandler) or in the onConfigure(SQLiteDatabase) callback. When foreign key constraints are disabled, the database does not check whether changes to the database will violate foreign key constraints. Likewise, when foreign key constraints are disabled, the database will not execute cascade delete or update triggers. As a result, it is possible for the database state to become inconsistent. To perform a database integrity check, call isDatabaseIntegrityOk() . This method must not be called while a transaction is in progress. See also SQLite Foreign Key Constraints for more details about foreign key constraint support.

          Parameters

          enable True to enable foreign key constraints, false to disable them.

          Sets the locale for this database. Does nothing if this database has the NO_LOCALIZED_COLLATORS flag set or was opened read only.

          Parameters

          locale The new locale. SQLException if the locale could not be set. The most common reason for this is that there is no collator available for the locale you requested. In this case the database remains unchanged.

          Control whether or not the SQLiteDatabase is made thread-safe by using locks around critical sections. This is pretty expensive, so if you know that your DB will only be used by a single thread then you should set this to false. The default is true.

          Parameters

          lockingEnabled set to true to enable locks, false otherwise

          Sets the maximum size of the prepared-statement cache for this database. (size of the cache = number of compiled-sql-statements stored in the cache). Maximum cache size can ONLY be increased from its current size (default = 10). If this method is called with smaller size than the current maximum value, then IllegalStateException is thrown. This method is thread-safe.

          Parameters

          cacheSize the size of the cache. can be (0 to MAX_SQL_CACHE_SIZE )

          Sets the maximum size the database will grow to. The maximum size cannot be set below the current size.

          Parameters

          numBytes the maximum database size, in bytes

          Sets the database page size. The page size must be a power of two. This method does not work if any data has been written to the database file, and must be called right after the database has been created.

          Parameters

          numBytes the database page size, in bytes

          Marks the current transaction as successful. Do not do any more database work between calling this and calling endTransaction. Do as little non-database work as possible in that situation too. If any errors are encountered between this and endTransaction the transaction will still be committed.

          Throws

          IllegalStateException if the current thread is not in a transaction or the transaction is already marked as successful. values a map from column names to new column values. null is a valid value that will be translated to NULL. whereClause the optional WHERE clause to apply when updating. Passing null will update all rows. whereArgs You may include ?s in the where clause, which will be replaced by the values from whereArgs. The values will be bound as Strings. values a map from column names to new column values. null is a valid value that will be translated to NULL. whereClause the optional WHERE clause to apply when updating. Passing null will update all rows. whereArgs You may include ?s in the where clause, which will be replaced by the values from whereArgs. The values will be bound as Strings. conflictAlgorithm for update conflict resolver This method is deprecated.
          if the db is locked more than once (becuase of nested transactions) then the lock will not be yielded. Use yieldIfContendedSafely instead.

          Temporarily end the transaction to let other threads run. The transaction is assumed to be successful so far. Do not call setTransactionSuccessful before calling this. When this returns a new transaction will have been created but not marked as successful.

          Returns

          • true if the transaction was yielded

          Temporarily end the transaction to let other threads run. The transaction is assumed to be successful so far. Do not call setTransactionSuccessful before calling this. When this returns a new transaction will have been created but not marked as successful. This assumes that there are no nested transactions (beginTransaction has only been called once) and will throw an exception if that is not the case.

          Returns

          • true if the transaction was yielded

            Temporarily end the transaction to let other threads run. The transaction is assumed to be successful so far. Do not call setTransactionSuccessful before calling this. When this returns a new transaction will have been created but not marked as successful. This assumes that there are no nested transactions (beginTransaction has only been called once) and will throw an exception if that is not the case.

            Parameters

            sleepAfterYieldDelay if > 0, sleep this long before starting a new transaction if the lock was actually yielded. This will allow other background threads to make some more progress than they would if we started the transaction immediately.