DatabaseConnectionUser class abstract

Manages a DatabaseConnection to send queries to the database.

Implementers
Available extensions

Constructors

DatabaseConnectionUser(QueryExecutor executor, {StreamQueryStore? streamQueries})
Constructs a database connection user, which is responsible to store query streams, wrap the underlying executor and perform type mapping.
DatabaseConnectionUser.delegate(DatabaseConnectionUser other, {QueryExecutor? executor, StreamQueryStore? streamQueries})
Creates another DatabaseConnectionUser by referencing the implementation from the other user.
DatabaseConnectionUser.fromConnection(DatabaseConnection connection)
Constructs a DatabaseConnectionUser that will use the provided DatabaseConnection.

Properties

attachedDatabase → GeneratedDatabase
The database class that this user is attached to.
no setter
connection → DatabaseConnection
The database connection used by this DatabaseConnectionUser.
final
executor → QueryExecutor
The executor to use when queries are executed.
no setter
hashCode → int
The hash code for this object.
no setterinherited
options → DriftDatabaseOptions
The DriftDatabaseOptions to use for this database instance.
no setter
resolvedEngine → DatabaseConnectionUser
A, potentially more specific, database engine based on the Zone context.
no setter
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
streamQueries → StreamQueryStore
Manages active streams from select statements.
no setter
typeMapping → SqlTypes
A SqlTypes mapping configuration to use when mapping values between Dart and SQL.
latefinal

Methods

$expandVar(int start, int amount) → String
Used by generated code to expand array variables.
$write(Component component, {bool? hasMultipleTables, int? startIndex}) → GenerationContext
Will be used by generated code to resolve inline Dart components in sql by writing the component.
$writeInsertable(TableInfo<Table, dynamic> table, Insertable insertable, {int? startIndex}) → GenerationContext
Writes column names and VALUES for an insert statement.
alias<T, D>(ResultSetImplementation<T, D> table, String alias) → T
Creates a copy of the table with an alias so that it can be used in the same query more than once.
batch(FutureOr<void> runInBatch(Batch batch)) → Future<void>
Runs statements inside a batch.
close() → Future<void>
Closes this database and releases associated resources.
computeWithDatabase<Ret>({required FutureOr<Ret> computation(DB), required DB connect(DatabaseConnection)}) → Future<Ret>

Available on DB, provided by the ComputeWithDriftIsolate extension

Spawns a short-lived isolate to run the computation with a drift database.
createStream<T extends Object>(QueryStreamFetcher<T> stmt) → Stream<T>
Creates and auto-updating stream from the given select statement. This method should not be used directly.
customInsert(String query, {List<Variable<Object>> variables = const [], Set<ResultSetImplementation>? updates}) → Future<int>
Executes a custom insert statement and returns the last inserted rowid.
customSelect(String query, {List<Variable<Object>> variables = const [], Set<ResultSetImplementation> readsFrom = const {}}) → Selectable<QueryRow>
Creates a custom select statement from the given sql query.
customSelectQuery(String query, {List<Variable<Object>> variables = const [], Set<ResultSetImplementation> readsFrom = const {}}) → Selectable<QueryRow>
Creates a custom select statement from the given sql query. To run the query once, use Selectable.get. For an auto-updating streams, set the set of tables the ready readsFrom and use Selectable.watch. If you know the query will never emit more than one row, you can also use getSingle and watchSingle which return the item directly without wrapping it into a list.
customStatement(String statement, [List? args]) → Future<void>
Executes the custom sql statement on the database.
customUpdate(String query, {List<Variable<Object>> variables = const [], Set<ResultSetImplementation>? updates, UpdateKind? updateKind}) → Future<int>
Executes a custom delete or update statement and returns the amount of rows that have been changed. You can use the updates parameter so that drift knows which tables are affected by your query. All select streams that depend on a table specified there will then update their data. For more accurate results, you can also set the updateKind parameter to UpdateKind.delete or UpdateKind.update. This is optional, but can improve the accuracy of query updates, especially when using triggers.
customWriteReturning(String query, {List<Variable<Object>> variables = const [], Set<ResultSetImplementation>? updates, UpdateKind? updateKind}) → Future<List<QueryRow>>
Runs a INSERT, UPDATE or DELETE statement returning rows.
delete<T extends Table, D>(TableInfo<T, D> table) → DeleteStatement<T, D>
Starts a DeleteStatement that can be used to delete rows from a table.
doWhenOpened<T>(FutureOr<T> fn(QueryExecutor e)) → Future<T>
Performs the async fn after this executor is ready, or directly if it's already ready.
exclusively<T>(Future<T> action()) → Future<T>
Obtains an exclusive lock on the current database context, runs action in it and then releases the lock.
into<T extends Table, D>(TableInfo<T, D> table) → InsertStatement<T, D>
Starts an InsertStatement for a given table. You can use that statement to write data into the table by using InsertStatement.insert.
markTablesUpdated(Iterable<TableInfo<Table, dynamic>> tables) → void
Marks the tables as updated.
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
notifyUpdates(Set<TableUpdate> updates) → void
Dispatches the set of updates to the stream query manager.
select<T extends HasResultSet, R>(ResultSetImplementation<T, R> table, {bool distinct = false}) → SimpleSelectStatement<T, R>
Starts a query on the given table.
selectExpressions(Iterable<Expression<Object>> columns) → Selectable<TypedResult>
Creates a select statement without a FROM clause selecting columns.
selectOnly<T extends HasResultSet, R>(ResultSetImplementation<T, R> table, {bool distinct = false}) → JoinedSelectStatement<T, R>
Starts a complex statement on table that doesn't necessarily use all of table's columns.
serializableConnection() → Future<DriftIsolate>

Available on DB, provided by the ComputeWithDriftIsolate extension

Creates a DriftIsolate that, when connected to, will run queries on the database already opened by this.
tableUpdates([TableUpdateQuery query = const TableUpdateQuery.any()]) → Stream<Set<TableUpdate>>
Listen for table updates reported through notifyUpdates.
toString() → String
A string representation of this object.
inherited
transaction<T>(Future<T> action(), {bool requireNew = false}) → Future<T>
Executes action in a transaction, which means that all its queries and updates will be called atomically.
update<Tbl extends Table, R>(TableInfo<Tbl, R> table) → UpdateStatement<Tbl, R>
Starts an UpdateStatement for the given table. You can use that statement to update individual rows in that table by setting a where clause on that table and then use UpdateStatement.write.

Operators

operator ==(Object other) → bool
The equality operator.
inherited