> ## Documentation Index > Fetch the complete documentation index at: https://docs.prefect.io/llms.txt > Use this file to discover all available pages before exploring further. # interface # `prefect.server.database.interface` ## Classes ### `DBSingleton` Ensures that only one database interface is created per unique key ### `PrefectDBInterface` An interface for backend-specific SqlAlchemy actions and ORM models. The REST API can be configured to run against different databases in order maintain performance at different scales. This interface integrates database- and dialect- specific configuration into a unified interface that the orchestration engine runs against. **Methods:** #### `Agent` ```python theme={null} Agent(self) -> type[orm_models.Agent] ``` An agent model #### `Artifact` ```python theme={null} Artifact(self) -> type[orm_models.Artifact] ``` An artifact orm model #### `ArtifactCollection` ```python theme={null} ArtifactCollection(self) -> type[orm_models.ArtifactCollection] ``` An artifact collection orm model #### `Automation` ```python theme={null} Automation(self) -> type[orm_models.Automation] ``` An automation model #### `AutomationBucket` ```python theme={null} AutomationBucket(self) -> type[orm_models.AutomationBucket] ``` An automation bucket model #### `AutomationEventFollower` ```python theme={null} AutomationEventFollower(self) -> type[orm_models.AutomationEventFollower] ``` A model capturing one event following another event #### `AutomationRelatedResource` ```python theme={null} AutomationRelatedResource(self) -> type[orm_models.AutomationRelatedResource] ``` An automation related resource model #### `Base` ```python theme={null} Base(self) -> type[orm_models.Base] ``` Base class for orm models #### `BlockDocument` ```python theme={null} BlockDocument(self) -> type[orm_models.BlockDocument] ``` A block document model #### `BlockDocumentReference` ```python theme={null} BlockDocumentReference(self) -> type[orm_models.BlockDocumentReference] ``` A block document reference model #### `BlockSchema` ```python theme={null} BlockSchema(self) -> type[orm_models.BlockSchema] ``` A block schema model #### `BlockSchemaReference` ```python theme={null} BlockSchemaReference(self) -> type[orm_models.BlockSchemaReference] ``` A block schema reference model #### `BlockType` ```python theme={null} BlockType(self) -> type[orm_models.BlockType] ``` A block type model #### `CompositeTriggerChildFiring` ```python theme={null} CompositeTriggerChildFiring(self) -> type[orm_models.CompositeTriggerChildFiring] ``` A model capturing a composite trigger's child firing #### `ConcurrencyLimit` ```python theme={null} ConcurrencyLimit(self) -> type[orm_models.ConcurrencyLimit] ``` A concurrency model #### `ConcurrencyLimitV2` ```python theme={null} ConcurrencyLimitV2(self) -> type[orm_models.ConcurrencyLimitV2] ``` A v2 concurrency model #### `Configuration` ```python theme={null} Configuration(self) -> type[orm_models.Configuration] ``` An configuration model #### `CsrfToken` ```python theme={null} CsrfToken(self) -> type[orm_models.CsrfToken] ``` A csrf token model #### `Deployment` ```python theme={null} Deployment(self) -> type[orm_models.Deployment] ``` A deployment orm model #### `DeploymentSchedule` ```python theme={null} DeploymentSchedule(self) -> type[orm_models.DeploymentSchedule] ``` A deployment schedule orm model #### `Event` ```python theme={null} Event(self) -> type[orm_models.Event] ``` An event model #### `EventResource` ```python theme={null} EventResource(self) -> type[orm_models.EventResource] ``` An event resource model #### `Flow` ```python theme={null} Flow(self) -> type[orm_models.Flow] ``` A flow orm model #### `FlowRun` ```python theme={null} FlowRun(self) -> type[orm_models.FlowRun] ``` A flow run orm model #### `FlowRunInput` ```python theme={null} FlowRunInput(self) -> type[orm_models.FlowRunInput] ``` A flow run input model #### `FlowRunState` ```python theme={null} FlowRunState(self) -> type[orm_models.FlowRunState] ``` A flow run state orm model #### `Log` ```python theme={null} Log(self) -> type[orm_models.Log] ``` A log orm model #### `SavedSearch` ```python theme={null} SavedSearch(self) -> type[orm_models.SavedSearch] ``` A saved search orm model #### `TaskRun` ```python theme={null} TaskRun(self) -> type[orm_models.TaskRun] ``` A task run orm model #### `TaskRunState` ```python theme={null} TaskRunState(self) -> type[orm_models.TaskRunState] ``` A task run state orm model #### `TaskRunStateCache` ```python theme={null} TaskRunStateCache(self) -> type[orm_models.TaskRunStateCache] ``` A task run state cache orm model #### `Variable` ```python theme={null} Variable(self) -> type[orm_models.Variable] ``` A variable model #### `WorkPool` ```python theme={null} WorkPool(self) -> type[orm_models.WorkPool] ``` A work pool orm model #### `WorkQueue` ```python theme={null} WorkQueue(self) -> type[orm_models.WorkQueue] ``` A work queue model #### `Worker` ```python theme={null} Worker(self) -> type[orm_models.Worker] ``` A worker process orm model #### `create_db` ```python theme={null} create_db(self) -> None ``` Create the database #### `dialect` ```python theme={null} dialect(self) -> type[sa.engine.Dialect] ``` #### `drop_db` ```python theme={null} drop_db(self) -> None ``` Drop the database by removing all tables directly. This reflects the actual database schema and drops every table rather than running all Alembic downgrade migrations in reverse. Running downgrades is fragile because individual migration downgrade steps may fail on real-world data (e.g. re-adding a foreign key constraint when orphaned references exist). Dropping tables directly is both faster and more robust. Reflection is used instead of `Base.metadata.drop_all()` so that tables created by migrations but not tracked in the ORM (e.g. `deployment_version`, `alembic_version`) are also removed. #### `engine` ```python theme={null} engine(self) -> AsyncEngine ``` Provides a SqlAlchemy engine against a specific database. #### `is_db_connectable` ```python theme={null} is_db_connectable(self) -> bool ``` Returns boolean indicating if the database is connectable. This method is used to determine if the server is ready to accept requests. #### `run_migrations_downgrade` ```python theme={null} run_migrations_downgrade(self, revision: str = '-1') -> None ``` Run all downgrade migrations #### `run_migrations_upgrade` ```python theme={null} run_migrations_upgrade(self) -> None ``` Run all upgrade migrations #### `session` ```python theme={null} session(self) -> AsyncSession ``` Provides a SQLAlchemy session. #### `session_context` ```python theme={null} session_context(self, begin_transaction: bool = False, with_for_update: bool = False) ``` Provides a SQLAlchemy session and a context manager for opening/closing the underlying connection. **Args:** * `begin_transaction`: if True, the context manager will begin a SQL transaction. Exiting the context manager will COMMIT or ROLLBACK any changes.