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.

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(sql: String, bindArgs: Stream<Array<out Any?>>): Int

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

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

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

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

batchRows

fun batchRows(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(sql: String, bindArgs: Array<out Any?>? = null): ISQLStatement

databaseConfig

fun databaseConfig(op: Int, value: Int)

delete

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

endTransaction

open override fun endTransaction()

exec

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

execute

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

executePreparedInsert

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

executePreparedUpdateDelete

fun executePreparedUpdateDelete(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(sql: String): ISQLRawStatement

query

open override fun query(query: ISQLQuery): ICursor

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

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

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

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

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

fun query(distinct: Boolean, table: String, columns: Array<out String>, selection: String, selectionArgs: Array<out Any?>, groupBy: String?, having: String?, 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(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(sql: String, bindArgs: ParameterRow, cancellationSignal: CancellationSignal): ICursor

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

Cancellable counterpart of queryForwardOnly.

queryUpTo

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

fun queryUpTo(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, 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