Method Detail

• releaseMemory

   static int releaseMemory()

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

• beginTransaction

   void beginTransaction()

  Begins a transaction in EXCLUSIVE mode.

  Transactions can be nested.When the outer transaction is ended all ofthe work done in that transaction and all of the nested transactions will be committed orrolled back. The changes will be rolled back if any transaction is ended without beingmarked 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();
    }
  

• beginTransactionNonExclusive

   void beginTransactionNonExclusive()

  Begins a transaction in IMMEDIATE mode. Transactions can be nested. Whenthe outer transaction is ended all of the work done in that transactionand all of the nested transactions will be committed or rolled back. Thechanges will be rolled back if any transaction is ended without beingmarked as clean (by calling setTransactionSuccessful). Otherwise theywill be committed.

  Here is the standard idiom for transactions:

    db.beginTransactionNonExclusive();
    try {
      ...
      db.setTransactionSuccessful();
    } finally {
      db.endTransaction();
    }
  

• beginTransactionDeferred

   void beginTransactionDeferred()

  Begins a transaction in DEFERRED mode.

• beginTransactionWithListenerDeferred

   void beginTransactionWithListenerDeferred(SQLiteTransactionListener transactionListener)

  Begins a transaction in DEFERRED mode.

  Parameters:

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

• beginTransactionWithListener

   void beginTransactionWithListener(SQLiteTransactionListener transactionListener)

  Begins a transaction in EXCLUSIVE mode.

  Transactions can be nested.When the outer transaction is ended all ofthe work done in that transaction and all of the nested transactions will be committed orrolled back. The changes will be rolled back if any transaction is ended without beingmarked 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.

• beginTransactionWithListenerNonExclusive

   void beginTransactionWithListenerNonExclusive(SQLiteTransactionListener transactionListener)

  Begins a transaction in IMMEDIATE mode. Transactions can be nested. Whenthe outer transaction is ended all of the work done in that transactionand all of the nested transactions will be committed or rolled back. Thechanges will be rolled back if any transaction is ended without beingmarked as clean (by calling setTransactionSuccessful). Otherwise theywill 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 thetransaction begins, commits, or is rolled back, eitherexplicitly or by a call to yieldIfContendedSafely.

• endTransaction

   void endTransaction()

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

• setTransactionSuccessful

   void setTransactionSuccessful()

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

• inTransaction

   boolean inTransaction()

  Returns true if the current thread has a transaction pending.

• isDbLockedByCurrentThread

   boolean isDbLockedByCurrentThread()

  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 connectionto the database meant that the thread was holding an actual lock on thedatabase. Nowadays, there is no longer a true "database lock" although threadsmay block if they cannot acquire a database connection to perform aparticular operation.

• yieldIfContendedSafely

   boolean yieldIfContendedSafely()

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

• yieldIfContendedSafely

   boolean yieldIfContendedSafely(long sleepAfterYieldDelay)

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

  Parameters:

  sleepAfterYieldDelay - if > 0, sleep this long before starting a new transaction ifthe lock was actually yielded.

• openDatabase

   static SQLiteDatabase openDatabase(String path, SQLiteDatabase.CursorFactory factory, int flags)

  Open the database according to the flags OpenFlags

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

  Parameters:

  path - to database file to open and/or create

  factory - an optional factory class that is called to instantiate acursor when query is called, or null for default

  flags - to control database access mode

• openDatabase

   static SQLiteDatabase openDatabase(String path, SQLiteDatabase.CursorFactory factory, int flags, DatabaseErrorHandler errorHandler)

  Open the database according to the flags OpenFlags

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

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

  Parameters:

  path - to database file to open and/or create

  factory - an optional factory class that is called to instantiate acursor when query is called, or null for default

  flags - to control database access mode

  errorHandler - the DatabaseErrorHandler obj to be used to handle corruptionwhen sqlite reports database corruption

• openDatabase

   static SQLiteDatabase openDatabase(SQLiteDatabaseConfiguration configuration, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler)

  Open the database according to the given configuration.

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

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

  Parameters:

  configuration - to database configuration to use

  factory - an optional factory class that is called to instantiate acursor when query is called, or null for default

  errorHandler - the DatabaseErrorHandler obj to be used to handle corruptionwhen sqlite reports database corruption

• openOrCreateDatabase

   static SQLiteDatabase openOrCreateDatabase(File file, SQLiteDatabase.CursorFactory factory)

  Equivalent to openDatabase(file.getPath(), factory, CREATE_IF_NECESSARY).

• openOrCreateDatabase

   static SQLiteDatabase openOrCreateDatabase(String path, SQLiteDatabase.CursorFactory factory)

  Equivalent to openDatabase(path, factory, CREATE_IF_NECESSARY).

• openOrCreateDatabase

   static SQLiteDatabase openOrCreateDatabase(String path, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler)

  Equivalent to openDatabase(path, factory, CREATE_IF_NECESSARY, errorHandler).

• deleteDatabase

   static boolean deleteDatabase(File file)

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

  Parameters:

  file - The database file path.

• reopenReadWrite

   void reopenReadWrite()

  Reopens the database in read-write mode.If the database is already read-write, does nothing.

• create

   static SQLiteDatabase create(SQLiteDatabase.CursorFactory factory)

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

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

  Parameters:

  factory - an optional factory class that is called to instantiate acursor when query is called

• addCustomFunction

  @Deprecated() void addCustomFunction(String name, int numArgs, SQLiteDatabase.CustomFunction function)

  Registers a CustomFunction callback as a function that can be called fromSQLite database triggers.

  Parameters:

  name - the name of the sqlite3 function

  numArgs - the number of arguments for the function

  function - callback to call when the function is executed

• addFunction

   void addFunction(String name, int numArgs, SQLiteDatabase.Function function)

  Registers a Function callback as a function that can be called fromSQLite database triggers.

  Parameters:

  name - the name of the sqlite3 function

  numArgs - the number of arguments for the function

  function - callback to call when the function is executed

• addFunction

   void addFunction(String name, int numArgs, SQLiteDatabase.Function function, int flags)

  Registers a Function callback as a function that can be called fromSQLite database triggers.

  Parameters:

  name - the name of the sqlite3 function

  numArgs - the number of arguments for the function

  function - callback to call when the function is executed

• setUpdateHook

   void setUpdateHook(SQLiteUpdateHook updateHook)

• getVersion

   int getVersion()

  Gets the database version.

• setVersion

   void setVersion(int version)

  Sets the database version.

  Parameters:

  version - the new database version

• getMaximumSize

   long getMaximumSize()

  Returns the maximum size the database may grow to.

• setMaximumSize

   long setMaximumSize(long numBytes)

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

  Parameters:

  numBytes - the maximum database size, in bytes

• getPageSize

   long getPageSize()

  Returns the current database page size, in bytes.

• setPageSize

   void setPageSize(long numBytes)

  Sets the database page size. The page size must be a power of two. Thismethod 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

• findEditTable

   static String findEditTable(String tables)

  Finds the name of the first table, which is editable.

  Parameters:

  tables - a list of tables

• compileStatement

   SQLiteStatement compileStatement(String sql)

  Compiles an SQL statement into a reusable pre-compiled statement object.The parameters are identical to execSQL. You may put ?s in thestatement and fill in those values with bindString and bindLong each time you want to run thestatement. Statements may not return result sets larger than 1x1.

  No two threads should be using the same SQLiteStatement at the same time.

  Parameters:

  sql - The raw SQL statement, may contain ?

• query

   Cursor query(boolean distinct, String table, Array<String> columns, String selection, Array<Object> selectionArgs, String groupBy, String having, String orderBy, String limit)

  Query the given URL, returning a Cursor over the result set.

  Parameters:

  distinct - true if you want each row to be unique, false otherwise.

  table - The table name to compile the query against.

  columns - A list of which columns to return.

  selection - A filter declaring which rows to return, formatted as anSQL WHERE clause (excluding the WHERE itself).

  selectionArgs - You may include ?s in selection, which will bereplaced by the values from selectionArgs, in order that theyappear in the selection.

  groupBy - A filter declaring how to group rows, formatted as an SQLGROUP BY clause (excluding the GROUP BY itself).

  having - A filter declare which row groups to include in the cursor,if row grouping is being used, formatted as an SQL HAVINGclause (excluding the HAVING itself).

  orderBy - How to order the rows, formatted as an SQL ORDER BY clause(excluding the ORDER BY itself).

  limit - Limits the number of rows returned by the query,formatted as LIMIT clause.

• query

   Cursor query(boolean distinct, String table, Array<String> columns, String selection, Array<Object> selectionArgs, String groupBy, String having, String orderBy, String limit, CancellationSignal cancellationSignal)

  Query the given URL, returning a Cursor over the result set.

  Parameters:

  distinct - true if you want each row to be unique, false otherwise.

  table - The table name to compile the query against.

  columns - A list of which columns to return.

  selection - A filter declaring which rows to return, formatted as anSQL WHERE clause (excluding the WHERE itself).

  selectionArgs - You may include ?s in selection, which will bereplaced by the values from selectionArgs, in order that theyappear in the selection.

  groupBy - A filter declaring how to group rows, formatted as an SQLGROUP BY clause (excluding the GROUP BY itself).

  having - A filter declare which row groups to include in the cursor,if row grouping is being used, formatted as an SQL HAVINGclause (excluding the HAVING itself).

  orderBy - How to order the rows, formatted as an SQL ORDER BY clause(excluding the ORDER BY itself).

  limit - Limits the number of rows returned by the query,formatted as LIMIT clause.

  cancellationSignal - A signal to cancel the operation in progress, or null if none.

• queryWithFactory

   Cursor queryWithFactory(SQLiteDatabase.CursorFactory cursorFactory, boolean distinct, String table, Array<String> columns, String selection, Array<Object> selectionArgs, String groupBy, String having, String orderBy, String limit)

  Query the given URL, returning a Cursor over the result set.

  Parameters:

  cursorFactory - the cursor factory to use, or null for the default factory

  distinct - true if you want each row to be unique, false otherwise.

  table - The table name to compile the query against.

  columns - A list of which columns to return.

  selection - A filter declaring which rows to return, formatted as anSQL WHERE clause (excluding the WHERE itself).

  selectionArgs - You may include ?s in selection, which will bereplaced by the values from selectionArgs, in order that theyappear in the selection.

  groupBy - A filter declaring how to group rows, formatted as an SQLGROUP BY clause (excluding the GROUP BY itself).

  having - A filter declare which row groups to include in the cursor,if row grouping is being used, formatted as an SQL HAVINGclause (excluding the HAVING itself).

  orderBy - How to order the rows, formatted as an SQL ORDER BY clause(excluding the ORDER BY itself).

  limit - Limits the number of rows returned by the query,formatted as LIMIT clause.

• queryWithFactory

   Cursor queryWithFactory(SQLiteDatabase.CursorFactory cursorFactory, boolean distinct, String table, Array<String> columns, String selection, Array<Object> selectionArgs, String groupBy, String having, String orderBy, String limit, CancellationSignal cancellationSignal)

  Query the given URL, returning a Cursor over the result set.

  Parameters:

  cursorFactory - the cursor factory to use, or null for the default factory

  distinct - true if you want each row to be unique, false otherwise.

  table - The table name to compile the query against.

  columns - A list of which columns to return.

  selection - A filter declaring which rows to return, formatted as anSQL WHERE clause (excluding the WHERE itself).

  selectionArgs - You may include ?s in selection, which will bereplaced by the values from selectionArgs, in order that theyappear in the selection.

  groupBy - A filter declaring how to group rows, formatted as an SQLGROUP BY clause (excluding the GROUP BY itself).

  having - A filter declare which row groups to include in the cursor,if row grouping is being used, formatted as an SQL HAVINGclause (excluding the HAVING itself).

  orderBy - How to order the rows, formatted as an SQL ORDER BY clause(excluding the ORDER BY itself).

  limit - Limits the number of rows returned by the query,formatted as LIMIT clause.

  cancellationSignal - A signal to cancel the operation in progress, or null if none.

• query

   Cursor query(String table, Array<String> columns, String selection, Array<Object> selectionArgs, String groupBy, String having, String orderBy)

  Query the given table, returning a Cursor over the result set.

  Parameters:

  table - The table name to compile the query against.

  columns - A list of which columns to return.

  selection - A filter declaring which rows to return, formatted as anSQL WHERE clause (excluding the WHERE itself).

  selectionArgs - You may include ?s in selection, which will bereplaced by the values from selectionArgs, in order that theyappear in the selection.

  groupBy - A filter declaring how to group rows, formatted as an SQLGROUP BY clause (excluding the GROUP BY itself).

  having - A filter declare which row groups to include in the cursor,if row grouping is being used, formatted as an SQL HAVINGclause (excluding the HAVING itself).

  orderBy - How to order the rows, formatted as an SQL ORDER BY clause(excluding the ORDER BY itself).

• query

   Cursor query(String table, Array<String> columns, String selection, Array<Object> selectionArgs, String groupBy, String having, String orderBy, String limit)

  Query the given table, returning a Cursor over the result set.

  Parameters:

  table - The table name to compile the query against.

  columns - A list of which columns to return.

  selection - A filter declaring which rows to return, formatted as anSQL WHERE clause (excluding the WHERE itself).

  selectionArgs - You may include ?s in selection, which will bereplaced by the values from selectionArgs, in order that theyappear in the selection.

  groupBy - A filter declaring how to group rows, formatted as an SQLGROUP BY clause (excluding the GROUP BY itself).

  having - A filter declare which row groups to include in the cursor,if row grouping is being used, formatted as an SQL HAVINGclause (excluding the HAVING itself).

  orderBy - How to order the rows, formatted as an SQL ORDER BY clause(excluding the ORDER BY itself).

  limit - Limits the number of rows returned by the query,formatted as LIMIT clause.

• query

   Cursor query(String query)

  Runs the provided SQL and returns a Cursor over the result set.

  Parameters:

  query - the SQL query.

• query

   Cursor query(String query, Array<Object> selectionArgs)

  Runs the provided SQL and returns a Cursor over the result set.

  Parameters:

  query - the SQL query.

  selectionArgs - You may include ?s in where clause in the query,which will be replaced by the values from selectionArgs.

• query

   Cursor query(SupportSQLiteQuery supportQuery)

  Runs the provided SQL and returns a Cursor over the result set.

  Parameters:

  supportQuery - the SQL query.

• query

   Cursor query(SupportSQLiteQuery supportQuery, CancellationSignal signal)

  Runs the provided SQL and returns a Cursor over the result set.

  Parameters:

  supportQuery - the SQL query.

  signal - A signal to cancel the operation in progress, or null if none.

• query

   Cursor query(SupportSQLiteQuery supportQuery, CancellationSignal signal)

  Runs the provided SQL and returns a Cursor over the result set.

  Parameters:

  supportQuery - the SQL query.

  signal - A signal to cancel the operation in progress, or null if none.

• rawQuery

   Cursor rawQuery(String sql, Array<Object> selectionArgs)

  Runs the provided SQL and returns a Cursor over the result set.

  Parameters:

  sql - the SQL query.

  selectionArgs - You may include ?s in where clause in the query,which will be replaced by the values from selectionArgs.

• rawQuery

   Cursor rawQuery(String sql, Array<Object> selectionArgs, CancellationSignal cancellationSignal)

  Runs the provided SQL and returns a Cursor over the result set.

  Parameters:

  sql - the SQL query.

  selectionArgs - You may include ?s in where clause in the query,which will be replaced by the values from selectionArgs.

  cancellationSignal - A signal to cancel the operation in progress, or null if none.

• rawQueryWithFactory

   Cursor rawQueryWithFactory(SQLiteDatabase.CursorFactory cursorFactory, String sql, Array<Object> selectionArgs, String editTable)

  Runs the provided SQL and returns a cursor over the result set.

  Parameters:

  cursorFactory - the cursor factory to use, or null for the default factory

  sql - the SQL query.

  selectionArgs - You may include ?s in where clause in the query,which will be replaced by the values from selectionArgs.

  editTable - the name of the first table, which is editable

• rawQueryWithFactory

   Cursor rawQueryWithFactory(SQLiteDatabase.CursorFactory cursorFactory, String sql, Array<Object> selectionArgs, String editTable, CancellationSignal cancellationSignal)

  Runs the provided SQL and returns a cursor over the result set.

  Parameters:

  cursorFactory - the cursor factory to use, or null for the default factory

  sql - the SQL query.

  selectionArgs - You may include ?s in where clause in the query,which will be replaced by the values from selectionArgs.

  editTable - the name of the first table, which is editable

  cancellationSignal - A signal to cancel the operation in progress, or null if none.

• insert

   long insert(String table, String nullColumnHack, ContentValues values)

  Convenience method for inserting a row into the database.

  Parameters:

  table - the table to insert the row into

  nullColumnHack - optional; may be null.SQL doesn't allow inserting a completely empty row withoutnaming at least one column name.

  values - this map contains the initial column values for therow.

• insertOrThrow

   long insertOrThrow(String table, String nullColumnHack, ContentValues values)

  Convenience method for inserting a row into the database.

  Parameters:

  table - the table to insert the row into

  nullColumnHack - optional; may be null.SQL doesn't allow inserting a completely empty row withoutnaming at least one column name.

  values - this map contains the initial column values for therow.

• replace

   long replace(String table, String nullColumnHack, ContentValues initialValues)

  Convenience method for replacing a row in the database.

  Parameters:

  table - the table in which to replace the row

  nullColumnHack - optional; may be null.SQL doesn't allow inserting a completely empty row withoutnaming at least one column name.

  initialValues - this map contains the initial column values forthe row.

• replaceOrThrow

   long replaceOrThrow(String table, String nullColumnHack, ContentValues initialValues)

  Convenience method for replacing a row in the database.

  Parameters:

  table - the table in which to replace the row

  nullColumnHack - optional; may be null.SQL doesn't allow inserting a completely empty row withoutnaming at least one column name.

  initialValues - this map contains the initial column values forthe row.

• insert

   long insert(String table, int conflictAlgorithm, ContentValues values)

  General method for inserting a row into the database.

  Parameters:

  table - the table to insert the row into

  conflictAlgorithm - for insert conflict resolver

  values - this map contains the initial column values for therow.

• insertWithOnConflict

   long insertWithOnConflict(String table, String nullColumnHack, ContentValues initialValues, int conflictAlgorithm)

  General method for inserting a row into the database.

  Parameters:

  table - the table to insert the row into

  nullColumnHack - optional; may be null.SQL doesn't allow inserting a completely empty row withoutnaming at least one column name.

  initialValues - this map contains the initial column values for therow.

  conflictAlgorithm - for insert conflict resolver

• delete

   int delete(String table, String whereClause, Array<String> whereArgs)

  Convenience method for deleting rows in the database.

  Parameters:

  table - the table to delete from

  whereClause - the optional WHERE clause to apply when deleting.Passing null will delete all rows.

  whereArgs - You may include ?s in the where clause, whichwill be replaced by the values from whereArgs.

• delete

   int delete(String table, String whereClause, Array<Object> whereArgs)

  Convenience method for deleting rows in the database.

  Parameters:

  table - the table to delete from

  whereClause - the optional WHERE clause to apply when deleting.Passing null will delete all rows.

  whereArgs - You may include ?s in the where clause, whichwill be replaced by the values from whereArgs.

• update

   int update(String table, ContentValues values, String whereClause, Array<String> whereArgs)

  Convenience method for updating rows in the database.

  Parameters:

  table - the table to update in

  values - a map from column names to new column values.

  whereClause - the optional WHERE clause to apply when updating.Passing null will update all rows.

  whereArgs - You may include ?s in the where clause, whichwill be replaced by the values from whereArgs.

• update

   int update(String table, int conflictAlgorithm, ContentValues values, String whereClause, Array<Object> whereArgs)

  Convenience method for updating rows in the database.

  Parameters:

  table - the table to update in

  conflictAlgorithm - for update conflict resolver

  values - a map from column names to new column values.

  whereClause - the optional WHERE clause to apply when updating.Passing null will update all rows.

  whereArgs - You may include ?s in the where clause, whichwill be replaced by the values from whereArgs.

• updateWithOnConflict

   int updateWithOnConflict(String table, ContentValues values, String whereClause, Array<String> whereArgs, int conflictAlgorithm)

  Convenience method for updating rows in the database.

  Parameters:

  table - the table to update in

  values - a map from column names to new column values.

  whereClause - the optional WHERE clause to apply when updating.Passing null will update all rows.

  whereArgs - You may include ?s in the where clause, whichwill be replaced by the values from whereArgs.

  conflictAlgorithm - for update conflict resolver

• execSQL

   void execSQL(String sql)

  Execute a single SQL statement that is NOT a SELECTor 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, update, et al, when possible.

  When using enableWriteAheadLogging, journal_mode isautomatically managed by this class. So, do not set journal_modeusing "PRAGMA journal_mode'" statement if your app is using

  Parameters:

  sql - the SQL statement to be executed.

• execSQL

   void execSQL(String sql, Array<Object> bindArgs)

  Execute a single SQL statement that is NOT a SELECT/INSERT/UPDATE/DELETE.

  For INSERT statements, use any of the following instead.

  • insert
  • insertOrThrow
  • insertWithOnConflict

  For UPDATE statements, use any of the following instead.

  • update
  • updateWithOnConflict

  For DELETE statements, use any of the following instead.

  • delete

  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 isautomatically managed by this class. So, do not set journal_modeusing "PRAGMA journal_mode'" statement if your app is using

  Parameters:

  sql - the SQL statement to be executed.

  bindArgs - only byte[], String, Long and Double are supported in bindArgs.

• validateSql

   void validateSql(@NonNull() String sql, @Nullable() CancellationSignal cancellationSignal)

  Verifies that a SQL SELECT statement is valid by compiling it.If the SQL statement is not valid, this method will throw a SQLiteException.

  Parameters:

  sql - SQL to be validated

  cancellationSignal - A signal to cancel the operation in progress, or null if none.

• isReadOnly

   boolean isReadOnly()

  Returns true if the database is opened as read only.

• isInMemoryDatabase

   boolean isInMemoryDatabase()

  Returns true if the database is in-memory db.

• isOpen

   boolean isOpen()

  Returns true if the database is currently open.

• needUpgrade

   boolean needUpgrade(int newVersion)

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

  Parameters:

  newVersion - The new version code.

• getPath

   final String getPath()

  Gets the path to the database file.

• setLocale

   void setLocale(Locale locale)

  Sets the locale for this database.

  Parameters:

  locale - The new locale.

• setMaxSqlCacheSize

   void setMaxSqlCacheSize(int cacheSize)

  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.

• setForeignKeyConstraintsEnabled

   void setForeignKeyConstraintsEnabled(boolean enable)

  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 foreignkey constraints are enabled for the session.

  A good time to call this method is right after calling openOrCreateDatabase or in the onConfigure callback.

  When foreign key constraints are disabled, the database does not check whetherchanges to the database will violate foreign key constraints. Likewise, whenforeign key constraints are disabled, the database will not execute cascadedelete or update triggers. As a result, it is possible for the databasestate 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 Constraintsfor more details about foreign key constraint support.

  Parameters:

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

• enableWriteAheadLogging

   boolean enableWriteAheadLogging()

  This method enables parallel execution of queries from multiple threads on thesame database. It does this by opening multiple connections to the databaseand using a different database connection for each query. The databasejournal 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 forreads and writes to occur on the database at the same time. Before modifying thedatabase, the writer implicitly acquires an exclusive lock on the database whichprevents readers from accessing the database until the write is completed.

  In contrast, when write-ahead logging is enabled (by calling this method), writeoperations 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 stateof the database as it was before the write began. When the write completes, readerson 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 beconcurrently accessed and modified by multiple threads at the same time.However, write-ahead logging uses significantly more memory than ordinaryjournaling because there are multiple connections to the same database.So if a database will only be used by a single thread, or if optimizingconcurrency is not very important, then write-ahead logging should be disabled.

  After calling this method, execution of queries in parallel is enabled as long asthe database remains open. To disable execution of queries in parallel, eithercall disableWriteAheadLogging or close the database and reopen it.

  The maximum number of connections used to execute queries in parallel isdependent 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 thetransaction was begun.

  Writers should use beginTransactionNonExclusive or beginTransactionWithListenerNonExclusive to start a transaction. Non-exclusive mode allows database file to be in readableby other threads executing queries.

  If the database has any attached databases, then execution of queries in parallel is NOTpossible. Likewise, write-ahead logging is not supported for read-only databasesor 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. This ismore 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 formore details about how write-ahead logging works.

• disableWriteAheadLogging

   void disableWriteAheadLogging()

  This method disables the features enabled by enableWriteAheadLogging.

• isWriteAheadLoggingEnabled

   boolean isWriteAheadLoggingEnabled()

  Returns true if write-ahead logging has been enabled for this database.

• getAttachedDbs

   List<Pair<String, String>> getAttachedDbs()

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

• isDatabaseIntegrityOk

   boolean isDatabaseIntegrityOk()

  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_checkcommand execution.

  Note that 'pragma integrity_check' on a database can take a long time.

• toString

   String toString()

• queryNumEntries

   long queryNumEntries(String table)

  Query the table for the number of rows in the table.

  Parameters:

  table - the name of the table to query

• queryNumEntries

   long queryNumEntries(String table, String selection)

  Query the table for the number of rows in the table.

  Parameters:

  table - the name of the table to query

  selection - A filter declaring which rows to return,formatted as an SQL WHERE clause (excluding the WHERE itself).

• queryNumEntries

   long queryNumEntries(String table, String selection, Array<String> selectionArgs)

  Query the table for the number of rows in the table.

  Parameters:

  table - the name of the table to query

  selection - A filter declaring which rows to return,formatted as an SQL WHERE clause (excluding the WHERE itself).

  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.

• longForQuery

   long longForQuery(String query, Array<String> selectionArgs)

  Utility method to run the query on the db and return the value in thefirst column of the first row.

• stringForQuery

   String stringForQuery(String query, Array<String> selectionArgs)

  Utility method to run the query on the db and return the value in thefirst column of the first row.

• stringForQuery

   static String stringForQuery(SQLiteStatement prog, Array<String> selectionArgs)

  Utility method to run the pre-compiled query and return the value in thefirst column of the first row.

• blobFileDescriptorForQuery

   ParcelFileDescriptor blobFileDescriptorForQuery(String query, Array<String> selectionArgs)

  Utility method to run the query on the db and return the blob value in thefirst column of the first row.

• blobFileDescriptorForQuery

   static ParcelFileDescriptor blobFileDescriptorForQuery(SQLiteStatement prog, Array<String> selectionArgs)

  Utility method to run the pre-compiled query and return the blob value in thefirst column of the first row.