Connection

Determine if the given exception was caused by a concurrency error such as a deadlock or serialization failure.

Determine if the given exception was caused by a lost connection.

No description

Handle an exception encountered when running a transacted statement.

Start a new database transaction.

Create a transaction within the database.

Handle an exception from a transaction beginning.

Commit the active database transaction.

Handle an exception encountered when committing a transaction.

Rollback the active database transaction.

Handle an exception from a rollback.

Forget a connection after a lost transaction operation.

Get the number of active transactions.

Determine whether this connection has a transaction that delays after-commit callbacks.

Without a transaction manager, any open transaction counts.

Execute the callback after a transaction commits.

The callback belongs to this connection's open transaction stack.

Execute the callback after commit, or immediately when no transaction exists.

Execute the callback after a transaction rolls back.

The callback belongs to this connection's open transaction stack.

Get the number of seconds until the given DateTime.

Get the "available at" UNIX timestamp.

If the given value is an interval, convert it to a DateTime instance.

Get the current system time as a UNIX timestamp.

Given a start time, format the total run time for human readability.

Register a custom macro.

Macros persist in a static property for the worker lifetime and apply to every subsequent call on the macroable class.

Mix another object into the class.

Delegates to macro() for each method; registered macros persist in a static property for the worker lifetime.

Check if macro is registered.

Flush the existing macros.

Clears worker-wide macros; concurrent coroutines may resolve different methods depending on timing.

Dynamically handle calls to the class.

Dynamically handle calls to the class.

Create a new database connection instance.

Set the query grammar to the default implementation.

Get the default query grammar instance.

Set the schema grammar to the default implementation.

Get the default schema grammar instance.

Set the query post processor to the default implementation.

Get the default post processor instance.

Get a schema builder instance for the connection.

Get the schema state for the connection.

Begin a fluent query against a database table.

Get a new query builder instance.

Run a select statement and return a single result.

Run a select statement and return the first column of the first row.

Run a select statement against the database.

Run a select statement against the database.

Run a select statement against the database and return all of the result sets.

Run a select statement against the database and return a generator.

Run an insert statement against the database.

Get the last insert ID.

Run an update statement against the database.

Run a delete statement against the database.

Execute an SQL statement and return the boolean result.

Run an SQL statement and get the number of rows affected.

Run a raw, unprepared query against the connection.

Get the number of open connections for the database.

Execute the given callback in "dry run" mode.

Execute the given callback without "pretending".

Execute the given callback in "dry run" mode.

Prepare the query bindings for execution.

Run a SQL statement and log its execution context.

Run a streaming SQL statement and log only its complete execution.

Run a SQL statement.

Create an exception containing the query and connection context.

Determine if the given database exception was caused by a unique constraint violation.

Determine if the given database exception was caused by an invalid or out of range value.

Determine if the given exception was thrown by the database driver.

Extract the index and columns that caused a unique constraint violation.

Log a query in the connection's query log.

Get the elapsed time in milliseconds since a given starting point.

Register a callback to be invoked when the connection queries for longer than a given amount of time.

Allow all the query duration handlers to run again, even if they have already run.

Get the duration of all run queries in milliseconds.

Reset the duration of all run queries.

Handle a query exception.

Handle a query exception that occurred during query execution.

Reconnect to the database.

Reconnect to the database if the driver resources are missing.

Reconnect for the given query, reporting driver failures as query failures.

Laravel reconnects lazily, so a failed connection surfaces from the query callback as a QueryException. Driver resources are established eagerly here instead.

Refresh the driver resources from a fresh connection.

Disconnect from the underlying driver resources.

Reset the logical transaction state.

Determine whether the connection has driver resources.

Disconnect the driver resources.

Implementations must forget the current resources through forgetDriverResources() in a finally block so cleanup failure cannot leave stale resources attached.

Forget the driver resources without performing physical cleanup.

Notify the resource owner that the current driver resources were forgotten.

Refresh the driver resources from a fresh connection.

Validate and capture a complete replacement set of driver resources and resource-associated metadata, including the configured database and table prefix baselines. Adopt it in a finally block around teardown. The original teardown throwable must propagate unchanged. Preserve the existing read / write role, which belongs to the current borrow.

Determine whether the connection is responsive.

Determine whether the connection may be reused.

Register a hook to be run just before a database transaction is started.

Register a hook to be run just before a database query is executed.

Clear all hooks registered to run before a database query.

Used by connection pooling to prevent callback leaks between requests.

Retain the physical database session for the duration of the callback.

Determine whether an operation requires the current physical session.

Drivers may extend this check to keep their physical session, for example when their own routing could send a later read to another server.

Begin a foreign key constraint suppression scope.

End a foreign key constraint suppression scope.

Reset all wrapper state for pool release.

Mutable connection metadata is restored to its configured values. Trustworthy physical session state is preserved and synchronized against the next coroutine's desired state when the connection is handed out again.

Get the number of SQL execution errors on this connection.

Used by connection pooling to detect stale connections.

Register a database query listener with the connection.

When the dispatcher is the application's worker-shared dispatcher, per-request registration persists and affects subsequent requests.

Fire an event for this connection.

Fire the given event.

Get a new raw query expression.

Escape a value for safe SQL embedding.

Escape a string value for safe SQL embedding.

Escape a boolean value for safe SQL embedding.

Escape a binary value for safe SQL embedding.

Determine if the database connection has modified any database records.

Indicate if any records have been modified.

Set the record modification state.

Reset the record modification state.

Indicate that the connection should use the write connection for reads.

Execute the given callback using the write connection for reads.

Resolve and record the connection role for an operation.

Mark the current physical session state as unknown.

Execute an internal physical-session statement.

Set the reconnect instance on the connection.

Set the resource owner's callback for forgotten driver resources.

Stop notifying the pool and restart error tracking once a leased physical connection is returned.

Get the database connection name.

Get the database connection with its read / write type.

Get the connection name to retain when subsequent operations may write.

Preserve a write alias so models reuse its transaction. Read aliases use the base connection so subsequent writes reach the primary.

Get an option from the configuration options.

Get the basic connection information as an array for debugging.

Get the database driver name.

Get a human-readable name for the given connection driver.

Get the default database driver name.

Get the query grammar used by the connection.

Set the query grammar used by the connection.

Get the schema grammar used by the connection.

Set the schema grammar used by the connection.

Get the query post processor used by the connection.

Set the query post processor used by the connection.

Get the event dispatcher used by the connection.

Set the event dispatcher instance on the connection.

A reusable physical connection keeps the dispatcher after release, so every later coroutine that borrows it dispatches query and transaction events to it.

Unset the event dispatcher for this connection.

A reusable physical connection keeps the null dispatcher after release, so every later coroutine that borrows it fires no query or transaction events.

Run the statement to start a new transaction.

Create a save point within the database.

Commit the active physical transaction.

Perform a rollback within the database.

Determine whether the connection has an active physical transaction.

Determine whether any owned driver resource has an active transaction.

Set the transaction manager instance on the connection.

A reusable physical connection keeps the manager after release, so every later coroutine that borrows it schedules after-commit callbacks on it.

Get the transaction manager instance.

Unset the transaction manager for this connection.

A reusable physical connection keeps the null manager after release, so every later coroutine that borrows it fails when scheduling after-commit callbacks.

Determine if the connection is in a "dry run".

Get the connection query log.

Get the connection query log with embedded bindings.

Clear the query log.

Enable the query log on the connection.

Disable the query log on the connection.

Determine whether we're logging queries.

Get the name of the connected database.

Set the name of the connected database.

Set the read / write type of the connection.

Retrieve the latest read / write type used.

Get the table prefix for the connection.

Set the table prefix in use by the connection.

Execute the given callback without table prefix.

Get the server version for the connection.

Get the ID of the last committed transaction.

Calculate the commit ID for a set of commit IDs that includes all of them.

Determine if the given commit ID has been applied.

Determine whether the server supports skipping locked rows.

Register a connection resolver.

The resolver persists in a static property for the worker lifetime and runs on every subsequent Connection construction for the given driver across all coroutines.

Get the connection resolver for the given driver.

Flush all static state.

Prepare the instance for cloning.