selekt-java/com.bloomberg.selekt/SQLDatabase

SQLDatabase

@ThreadSafe

class SQLDatabase(val path: String, sqlite: SQLite, configuration: DatabaseConfiguration, key: DatabaseKey?, random: IRandom = CommonThreadLocalRandom) : IDatabase, SharedCloseable(source)

The use of ThreadLocal underpins SQLDatabase's thread-safety.

A thread can acquire at most one connection session per database instance. Sessions hold at most one connection at any given time, and exclusively. Sessions control all access to a database's connections and each session is thread-bound. This prevents two threads from ever sharing a single connection.

Parameters marked TrustedSql become part of SQL syntax. They must contain only application-controlled SQL; pass external values through the corresponding bind-argument parameters.

This is the same strategy Google employs in the Android SDK.

Constructors

SQLDatabase

constructor(path: String, sqlite: SQLite, configuration: DatabaseConfiguration, key: DatabaseKey?, random: IRandom = CommonThreadLocalRandom)

Types

Companion

object Companion

Properties

inTransaction

open override val inTransaction: Boolean

isCurrentThreadSessionActive

val isCurrentThreadSessionActive: Boolean

isInterrupted

val isInterrupted: Boolean

Returns true if any database connection managed by this database has been interrupted and has not yet completed. This method is safe to call from any thread.

path

val path: String

version

open override var version: Int

Functions

batch

fun batch(@TrustedSql sql: String, bindArgs: Stream<Array<out Any?>>): Int

fun batch(@TrustedSql sql: String, bindArgs: Iterable<Array<out Any?>>): Int

fun batch(@TrustedSql sql: String, bindArgs: List<Array<out Any?>>): Int

fun batch(@TrustedSql sql: String, bindArgs: Sequence<Array<out Any?>>): Int

fun batch(@TrustedSql sql: String, bindArgs: Array<out Array<out Any?>>, fromIndex: Int = 0, toIndex: Int = bindArgs.size): Int

batchRows

fun batchRows(@TrustedSql sql: String, bindArgs: Iterable<ParameterRow>): Int

beginDeferredTransaction

open override fun beginDeferredTransaction()

beginDeferredTransactionWithListener

open override fun beginDeferredTransactionWithListener(listener: SQLTransactionListener)

beginExclusiveTransaction

open override fun beginExclusiveTransaction()

beginExclusiveTransactionWithListener

open override fun beginExclusiveTransactionWithListener(listener: SQLTransactionListener)

beginImmediateTransaction

open override fun beginImmediateTransaction()

beginImmediateTransactionWithListener

open override fun beginImmediateTransactionWithListener(listener: SQLTransactionListener)

fun close()

compileStatement

open override fun compileStatement(@TrustedSql sql: String, bindArgs: Array<out Any?>? = null): ISQLStatement

databaseConfig

fun databaseConfig(op: Int, value: Int)

delete

open override fun delete(table: String, @TrustedSql whereClause: String, whereArgs: Array<out Any?>): Int

endTransaction

open override fun endTransaction()

exec

open override fun exec(@TrustedSql sql: String, bindArgs: Array<out Any?>? = null)

execute

fun <T> execute(readOnly: Boolean, block: SQLDatabase.() -> T): T

executePreparedInsert

fun executePreparedInsert(@TrustedSql sql: String, bindArgs: ParameterRow): Long

executePreparedUpdateDelete

fun executePreparedUpdateDelete(@TrustedSql sql: String, bindArgs: ParameterRow): Int

insert

open override fun insert(table: String, values: IContentValues, conflictAlgorithm: IConflictAlgorithm): Long

insertBlobs

fun insertBlobs(batch: StreamingBlobBatch, rows: Iterable<StreamingBlobRow>): Int

Inserts rowid-table rows and writes their BLOB values incrementally with bounded memory.

fun insertBlobs(batch: StreamingBlobBatch, rows: Iterable<StreamingBlobRow>, cancellationSignal: CancellationSignal): Int

Cancellable counterpart of insertBlobs.

interrupt

fun interrupt()

Interrupts all database connections managed by this database. This causes any pending database operations on those connections to abort and return at the earliest opportunity. This method is safe to call from any thread.

isOpen

fun isOpen(): Boolean

openSession

fun openSession(beforePrimaryConnectionAccess: () -> Unit, onTransactionStateChanged: (Boolean) -> Unit): SQLDatabaseSession

Opens an explicitly owned session with callbacks for coordinating its lifecycle with an external owner. The returned session is not thread-safe and must be closed when no longer needed.

pragma

fun pragma(pragma: SQLitePragma): String

fun pragma(key: String): String

fun pragma(pragma: SQLitePragma, value: Any): String?

fun pragma(key: String, value: Any): String?

prepare

fun prepare(@TrustedSql sql: String): ISQLRawStatement

query

open override fun query(query: ISQLQuery): ICursor

open override fun query(@TrustedSql sql: String, selectionArgs: Array<out Any?>): ICursor

fun query(@TrustedSql sql: String, bindArgs: ParameterRow, cancellationSignal: CancellationSignal): ICursor

open override fun query(distinct: Boolean, @TrustedSql table: String, @TrustedSql columns: Array<out String>, @TrustedSql selection: String, selectionArgs: Array<out Any?>, @TrustedSql groupBy: String?, @TrustedSql having: String?, @TrustedSql orderBy: String?, limit: Int?): ICursor

fun query(query: ISQLQuery, cancellationSignal: CancellationSignal): ICursor

fun query(@TrustedSql sql: String, selectionArgs: Array<out Any?>, cancellationSignal: CancellationSignal): ICursor

fun query(distinct: Boolean, @TrustedSql table: String, @TrustedSql columns: Array<out String>, @TrustedSql selection: String, selectionArgs: Array<out Any?>, @TrustedSql groupBy: String?, @TrustedSql having: String?, @TrustedSql orderBy: String?, limit: Int?, cancellationSignal: CancellationSignal): ICursor

Executes a cancellable query. If the cancellationSignal is cancelled from another thread, the query will be aborted at the earliest opportunity and an OperationCancelledException will be thrown.

queryForwardOnly

fun queryForwardOnly(@TrustedSql sql: String, selectionArgs: Array<out Any?>): ICursor

Returns a forward-only streaming ICursor backed by a ForwardCursor. The caller must close the returned cursor to release the underlying prepared statement back to the connection's cache and to release the session's connection back to the pool.

fun queryForwardOnly(@TrustedSql sql: String, bindArgs: ParameterRow, cancellationSignal: CancellationSignal): ICursor

fun queryForwardOnly(@TrustedSql sql: String, selectionArgs: Array<out Any?>, cancellationSignal: CancellationSignal): ICursor

Cancellable counterpart of queryForwardOnly.

queryUpTo

fun queryUpTo(@TrustedSql sql: String, bindArgs: ParameterRow, maximumRows: Int, cancellationSignal: CancellationSignal): ICursor

fun queryUpTo(@TrustedSql sql: String, selectionArgs: Array<out Any?>, maximumRows: Int, cancellationSignal: CancellationSignal): ICursor

Executes a cancellable query while stepping no more than maximumRows.

readFromBlob

fun readFromBlob(table: String, column: String, row: Long, offset: Int, limit: Int, stream: OutputStream)

fun readFromBlob(name: String, table: String, column: String, row: Long, offset: Int, limit: Int, stream: OutputStream)

release

fun release()

releaseMemory

fun releaseMemory(priority: Priority)

releaseSavepoint

fun releaseSavepoint(name: String)

retain

fun retain()

rollbackToSavepoint

fun rollbackToSavepoint(name: String)

setProgressHandler

fun setProgressHandler(instructionCount: Int, handler: SQLProgressHandler?)

Registers a progress handler that is invoked periodically during long-running SQL statements on all database connections managed by this database. If the handler returns non-zero, the operation is interrupted.

setSavepoint

fun setSavepoint(name: String? = null): String

setTransactionSuccessful

open override fun setTransactionSuccessful()

sizeOfBlob

fun sizeOfBlob(table: String, column: String, row: Long): Int

fun sizeOfBlob(name: String, table: String, column: String, row: Long): Int

transact

fun <T> transact(transactionMode: SQLiteTransactionMode = SQLiteTransactionMode.EXCLUSIVE, block: SQLDatabase.() -> T): T

fun <D, T> transact(database: D, transactionMode: SQLiteTransactionMode, block: D.() -> T): T

fun <T> transact(listener: SQLTransactionListener, transactionMode: SQLiteTransactionMode = SQLiteTransactionMode.EXCLUSIVE, block: SQLDatabase.() -> T): T

tryRetain

fun tryRetain(): Boolean

update

open override fun update(table: String, values: IContentValues, @TrustedSql whereClause: String, whereArgs: Array<out Any?>, conflictAlgorithm: IConflictAlgorithm): Int

upsert

open override fun upsert(table: String, insertValues: IContentValues, columns: Array<out String>, updateValues: IContentValues): Long

withCancellationSignal

fun <T> withCancellationSignal(cancellationSignal: CancellationSignal, primary: Boolean = false, block: SQLDatabase.() -> T): T

writeToBlob

fun writeToBlob(table: String, column: String, row: Long, offset: Int, stream: InputStream)

fun writeToBlob(name: String, table: String, column: String, row: Long, offset: Int, stream: InputStream)

yieldTransaction

open override fun yieldTransaction(): Boolean

open override fun yieldTransaction(pauseMillis: Long): Boolean

SQLDatabase

See also

Constructors

Types

Properties

Functions