DatabaseManager

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.

Boot-only. 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.

Boot-only. 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.

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

Dynamically handle calls to the class.

Dynamically pass methods to the default connection.

Create a new database manager instance.

Get a database connection instance.

Delegates to ConnectionResolver for pooled, per-coroutine connection management. Resolves the default connection name here (checking Context for usingConnection override) before passing to the resolver.

Resolve a connection directly without using the connection pool.

This method is used by SimpleConnectionResolver for testing and Capsule environments where connection pooling is not needed. It manages connections in the $connections array like Laravel's original DatabaseManager.

Build a database connection instance from the given configuration.

Get a database connection instance from the given configuration.

Make the database connection instance.

Get the configuration for a connection.

Prepare the database connection instance.

Dispatch the ConnectionEstablished event if the event dispatcher is available.

Disconnect from the given database and flush its pool.

In pooled mode, this disconnects the current coroutine's connection, clears its context key (so the next connection() call gets a fresh pooled connection), and flushes the pool. Use this when connection configuration has changed and you need to fully reset.

Boot or tests only. Flushes the shared pool used by every coroutine; concurrent coroutines holding pooled connections will release them back into a discarded pool, and the current coroutine may briefly hold two pooled connections (the old one releases via defer at coroutine end).

Disconnect from the given database.

In pooled mode, this nulls the PDOs on the current coroutine's connection (if one exists), forcing a reconnect on the next query. Does not clear context or affect the pool - the connection is still released at coroutine end.

In non-pooled mode (SimpleConnectionResolver), disconnects the connection stored in the $connections array.

Reconnect to the given database.

In pooled mode, if this coroutine already has a connection, reconnects its PDOs and returns it. In non-pooled mode, refreshes the existing connection's PDOs in-place. Otherwise gets a fresh connection.

Set the default database connection for the callback execution.

Uses Context for coroutine-safe state management, ensuring concurrent requests don't interfere with each other's default connection.

Refresh the PDO connections on a given connection.

Get the default connection name.

Checks Context first for per-coroutine override (from usingConnection()), then falls back to the global config default.

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

Boot-only. The callback persists on the database manager for the worker lifetime and affects every subsequent request for the same connection.

Allow all the query duration handlers to run again for the current connection.

Set the default connection name for the current execution context.

Writes to coroutine Context so concurrent requests in the same Swoole worker are not affected. A null value clears the override and getDefaultConnection() falls back to config('database.default').

Get a config value.

Get the context key for storing a connection.

Uses the same format as ConnectionResolver for consistency.

Get all coroutine/cache variants for a connection name.

Get the current effective connection name.

Register the manager-level query duration listener.

Get the coroutine-local key for a query duration handler registration.

Get all of the supported drivers.

Get all of the drivers that are actually available.

Register an extension connection resolver.

Extensions are stored on the ConnectionFactory so they are consulted by both the pooled path (PooledConnection → factory) and the non-pooled path (DatabaseManager → factory).

Boot-only. The resolver persists on the singleton ConnectionFactory for the worker lifetime and applies to every subsequent connection.

Remove an extension connection resolver.

Boot or tests only. Mutates the singleton ConnectionFactory's extension registry; concurrent coroutines establishing connections may see the resolver removed mid-resolution.

Return all of the created connections.

Note: In Hypervel's pooled connection mode, connections are stored per-coroutine in Context rather than in this array. This method returns an empty array in normal pooled operation. Use the pool infrastructure to inspect active connections if needed.

Purge all connections on the current manager instance.

Resolves the DatabaseManager from the container and disconnects every active connection. Safe to call when no container or no database manager exists (e.g., unit tests).

Uses bound() - not has() - because Application::has() falls through to class_exists(), so any string that case-insensitively matches a loaded PHP class name would falsely report bound. bound() only checks bindings/instances/aliases.

Boot or tests only. Calls purge() on every connection (flushes the shared pools); concurrent coroutines lose their cached connection references mid-request.

Set the database reconnector callback.

Boot-only. The reconnector persists on the singleton DatabaseManager for the worker lifetime and is invoked for every disconnected connection across all coroutines.

Set the application instance used by the manager.

Tests only. Swaps the singleton's application reference; per-request use races across coroutines and breaks every concurrent database operation.

Flush all static state.