SQLAlchemy ORM

https://docs.sqlalchemy.org/en/20/orm/
Admin
SQLAlchemy ORM is an Object Relational Mapper that provides high-level SQL construction and...
Tokens:1,112,137
Snippets:7,872
Trust Score:9.7
Update:2 days ago
Show doc for...
Tokens:
Raw
### Setup imports and Base class for relationship examples

Source: https://docs.sqlalchemy.org/en/20/orm/basic_relationships.html

Common setup for all examples: imports and a DeclarativeBase subclass named Base.

```python
from __future__ import annotations
from typing import List

from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import relationship


class Base(DeclarativeBase):
    pass
```

--------------------------------

### Define ORM Models and Setup Session for DML Examples

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/_dml_setup.html

Defines the Base, User, Address, LogRecord, and Employee/Manager/Engineer models, then creates an in-memory SQLite engine, creates tables, and opens a session with a transaction. Use this as the prerequisite setup for the ORM DML examples.

```python
>>> from typing import List
>>> from typing import Optional
>>> import datetime
>>>
>>> from sqlalchemy import Column
>>> from sqlalchemy import create_engine
>>> from sqlalchemy import ForeignKey
>>> from sqlalchemy import Table
>>> from sqlalchemy.orm import DeclarativeBase
>>> from sqlalchemy.orm import Mapped
>>> from sqlalchemy.orm import mapped_column
>>> from sqlalchemy.orm import relationship
>>> from sqlalchemy.orm import Session
>>>
>>>
>>> class Base(DeclarativeBase):
...     pass
>>> class User(Base):
...     __tablename__ = "user_account"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     name: Mapped[str] = mapped_column(unique=True)
...     fullname: Mapped[Optional[str]]
...     species: Mapped[Optional[str]]
...     addresses: Mapped[List["Address"]] = relationship(back_populates="user")
...
...     def __repr__(self) -> str:
...         return f"User(name={self.name!r}, fullname={self.fullname!r})"
>>> class Address(Base):
...     __tablename__ = "address"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     user_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))
...     email_address: Mapped[str]
...     user: Mapped[User] = relationship(back_populates="addresses")
...
...     def __repr__(self) -> str:
...         return f"Address(email_address={self.email_address!r})"
>>> class LogRecord(Base):
...     __tablename__ = "log_record"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     message: Mapped[str]
...     code: Mapped[str]
...     timestamp: Mapped[datetime.datetime]
...
...     def __repr__(self):
...         return f"LogRecord({self.message!r}, {self.code!r}, {self.timestamp!r})"

>>> class Employee(Base):
...     __tablename__ = "employee"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     name: Mapped[str]
...     type: Mapped[str]
...
...     def __repr__(self):
...         return f"{self.__class__.__name__}({self.name!r})"
...
...     __mapper_args__ = {
...         "polymorphic_identity": "employee",
...         "polymorphic_on": "type",
...     }
>>> class Manager(Employee):
...     __tablename__ = "manager"
...     id: Mapped[int] = mapped_column(ForeignKey("employee.id"), primary_key=True)
...     manager_name: Mapped[str]
...
...     def __repr__(self):
...         return f"{self.__class__.__name__}({self.name!r}, manager_name={self.manager_name!r})"
...
...     __mapper_args__ = {
...         "polymorphic_identity": "manager",
...     }
>>> class Engineer(Employee):
...     __tablename__ = "engineer"
...     id: Mapped[int] = mapped_column(ForeignKey("employee.id"), primary_key=True)
...     engineer_info: Mapped[str]
...
...     def __repr__(self):
...         return f"{self.__class__.__name__}({self.name!r}, engineer_info={self.engineer_info!r})"
...
...     __mapper_args__ = {
...         "polymorphic_identity": "engineer",
...     }

>>> engine = create_engine("sqlite+pysqlite:///:memory:", echo=True)
>>> Base.metadata.create_all(engine)
BEGIN ...
>>> conn = engine.connect()
>>> session = Session(conn)
>>> conn.begin()
BEGIN ...
```

--------------------------------

### ORM Query Guide SELECT Setup: Models and Fixture Data

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/_plain_setup.html

Defines the User, Address, Order, and Item mapped classes with relationships, creates an in-memory SQLite database, and inserts sample data. Use this as the foundation for the SELECT examples in the ORM Querying Guide.

```python
>>> from typing import List
>>> from typing import Optional
>>>
>>> from sqlalchemy import Column
>>> from sqlalchemy import create_engine
>>> from sqlalchemy import ForeignKey
>>> from sqlalchemy import Table
>>> from sqlalchemy.orm import DeclarativeBase
>>> from sqlalchemy.orm import Mapped
>>> from sqlalchemy.orm import mapped_column
>>> from sqlalchemy.orm import relationship
>>> from sqlalchemy.orm import Session
>>>
>>>
>>> class Base(DeclarativeBase):
...     pass
>>> class User(Base):
...     __tablename__ = "user_account"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     name: Mapped[str]
...     fullname: Mapped[Optional[str]]
...     addresses: Mapped[List["Address"]] = relationship(back_populates="user")
...     orders: Mapped[List["Order"]] = relationship()
...
...     def __repr__(self) -> str:
...         return f"User(id={self.id!r}, name={self.name!r}, fullname={self.fullname!r})"
>>> class Address(Base):
...     __tablename__ = "address"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     user_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))
...     email_address: Mapped[str]
...     user: Mapped[User] = relationship(back_populates="addresses")
...
...     def __repr__(self) -> str:
...         return f"Address(id={self.id!r}, email_address={self.email_address!r})"
>>> order_items_table = Table(
...     "order_items",
...     Base.metadata,
...     Column("order_id", ForeignKey("user_order.id"), primary_key=True),
...     Column("item_id", ForeignKey("item.id"), primary_key=True),
... )
>>>
>>> class Order(Base):
...     __tablename__ = "user_order"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     user_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))
...     items: Mapped[List["Item"]] = relationship(secondary=order_items_table)
>>> class Item(Base):
...     __tablename__ = "item"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     name: Mapped[str]
...     description: Mapped[str]
>>> engine = create_engine("sqlite+pysqlite:///:memory:", echo=True)
>>> Base.metadata.create_all(engine)
BEGIN ...
>>> conn = engine.connect()
>>> session = Session(conn)
>>> session.add_all(
...     [
...         User(
...             name="spongebob",
...             fullname="Spongebob Squarepants",
...             addresses=[Address(email_address="[email protected]")],
...         ),
...         User(
...             name="sandy",
...             fullname="Sandy Cheeks",
...             addresses=[
...                 Address(email_address="[email protected]"),
...                 Address(email_address="[email protected]"),
...             ],
...         ),
...         User(
...             name="patrick",
...             fullname="Patrick Star",
...             addresses=[Address(email_address="[email protected]")],
...         ),
...         User(
...             name="squidward",
...             fullname="Squidward Tentacles",
...             addresses=[Address(email_address="[email protected]")],
...         ),
...         User(name="ehkrabs", fullname="Eugene H. Krabs"),
...     ]
... )
>>> session.commit()
BEGIN ... COMMIT
>>> conn.begin()
BEGIN ...
```

--------------------------------

### Create a Session instance

Source: https://docs.sqlalchemy.org/en/20/orm/session_transaction.html

Initializes a Session bound to an engine. This is the starting point for the transaction examples.

```python
from sqlalchemy.orm import Session

session = Session(engine)
```

--------------------------------

### Async Core Example with create_async_engine and run_sync

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Complete example of using AsyncEngine with SQLite. Shows creating tables via run_sync, inserting rows, selecting data, and disposing the engine. The output includes SQL logging.

```python
>>> import asyncio

>>> from sqlalchemy import Column
>>> from sqlalchemy import MetaData
>>> from sqlalchemy import select
>>> from sqlalchemy import String
>>> from sqlalchemy import Table
>>> from sqlalchemy.ext.asyncio import create_async_engine

>>> meta = MetaData()
>>> t1 = Table("t1", meta, Column("name", String(50), primary_key=True))


>>> async def async_main() -> None:
...     engine = create_async_engine("sqlite+aiosqlite://", echo=True)
...
...     async with engine.begin() as conn:
...         await conn.run_sync(meta.drop_all)
...         await conn.run_sync(meta.create_all)
...
...         await conn.execute(
...             t1.insert(), [{"name": "some name 1"}, {"name": "some name 2"}]
...         )
...
...     async with engine.connect() as conn:
...         # select a Result, which will be delivered with buffered
...         # results
...         result = await conn.execute(select(t1).where(t1.c.name == "some name 1"))
...
...         print(result.fetchall())
...
...     # for AsyncEngine created in function scope, close and
...     # clean-up pooled connections
...     await engine.dispose()


>>> asyncio.run(async_main())
BEGIN (implicit)
...
CREATE TABLE t1 (
    name VARCHAR(50) NOT NULL,
    PRIMARY KEY (name)
)
...
INSERT INTO t1 (name) VALUES (?)
[...] [('some name 1',), ('some name 2',)]
COMMIT
BEGIN (implicit)
SELECT t1.name
FROM t1
WHERE t1.name = ?
[...] ('some name 1',)
[('some name 1',)]
ROLLBACK
```

--------------------------------

### Define User and Book models and populate sample data

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/_deferred_setup.html

Defines User and Book ORM classes with relationships, creates an in-memory SQLite database, and inserts sample users and books. Use this setup to follow the Column Loading Options examples.

```python
>>> from typing import List
>>> from typing import Optional
>>>
>>> from sqlalchemy import Column
>>> from sqlalchemy import create_engine
>>> from sqlalchemy import ForeignKey
>>> from sqlalchemy import LargeBinary
>>> from sqlalchemy import Table
>>> from sqlalchemy import Text
>>> from sqlalchemy.orm import DeclarativeBase
>>> from sqlalchemy.orm import Mapped
>>> from sqlalchemy.orm import mapped_column
>>> from sqlalchemy.orm import relationship
>>> from sqlalchemy.orm import Session
>>>
>>>
>>> class Base(DeclarativeBase):
...     pass
>>> class User(Base):
...     __tablename__ = "user_account"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     name: Mapped[str]
...     fullname: Mapped[Optional[str]]
...     books: Mapped[List["Book"]] = relationship(back_populates="owner")
...
...     def __repr__(self) -> str:
...         return f"User(id={self.id!r}, name={self.name!r}, fullname={self.fullname!r})"
>>> class Book(Base):
...     __tablename__ = "book"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     owner_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))
...     title: Mapped[str]
...     summary: Mapped[str] = mapped_column(Text)
...     cover_photo: Mapped[bytes] = mapped_column(LargeBinary)
...     owner: Mapped["User"] = relationship(back_populates="books")
...
...     def __repr__(self) -> str:
...         return f"Book(id={self.id!r}, title={self.title!r})"
>>> engine = create_engine("sqlite+pysqlite:///:memory:", echo=True)
>>> Base.metadata.create_all(engine)
BEGIN ...
>>> conn = engine.connect()
>>> session = Session(conn)
>>> session.add_all(
...     [
...         User(
...             name="spongebob",
...             fullname="Spongebob Squarepants",
...             books=[
...                 Book(
...                     title="100 Years of Krabby Patties",
...                     summary="some long summary",
...                     cover_photo=b"binary_image_data",
...                 ),
...                 Book(
...                     title="Sea Catch 22",
...                     summary="another long summary",
...                     cover_photo=b"binary_image_data",
...                 ),
...                 Book(
...                     title="The Sea Grapes of Wrath",
...                     summary="yet another summary",
...                     cover_photo=b"binary_image_data",
...                 ),
...             ],
...         ),
...         User(
...             name="sandy",
...             fullname="Sandy Cheeks",
...             books=[
...                 Book(
...                     title="A Nut Like No Other",
...                     summary="some long summary",
...                     cover_photo=b"binary_image_data",
...                 ),
...                 Book(
...                     title="Geodesic Domes: A Retrospective",
...                     summary="another long summary",
...                     cover_photo=b"binary_image_data",
...                 ),
...                 Book(
...                     title="Rocketry for Squirrels",
...                     summary="yet another summary",
...                     cover_photo=b"binary_image_data",
...                 ),
...             ],
...         ),
...     ]
... )
>>> session.commit()
BEGIN ... COMMIT
>>> session.close()
>>> conn.begin()
BEGIN ...

```

--------------------------------

### SQL equivalent of Query.select_from() example

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/query.html

The SQL produced by the Query.select_from() example, selecting from user and joining address.

```sql
SELECT address.* FROM user
JOIN address ON user.id=address.user_id
WHERE user.name = :name_1
```

--------------------------------

### Output of before_commit event example

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

The output produced when running the before_commit event example.

```text
before commit
```

--------------------------------

### AsyncTransaction.start()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Start this transaction.

```APIDOC
## AsyncTransaction.start()

### Description
Start this transaction.

### Method
`start()`

### Parameters
None.

### Returns
None.
```

--------------------------------

### AsyncConnection.start()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Start a transaction on this connection.

```APIDOC
## AsyncConnection.start()

### Description
Start a transaction on this connection.

### Method
`start()`

### Parameters
None.

### Returns
An AsyncTransaction object.
```

--------------------------------

### AsyncConnection.start()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Start the connection. This is an async method that must be called before using the connection.

```APIDOC
## AsyncConnection.start()

### Description
Starts the connection asynchronously. This method is typically called automatically when using the connection as a context manager.

### Method
`start()`

### Parameters
None.

### Returns
None.

### Example
```python
conn = async_engine.connect()
await conn.start()
# use conn
await conn.aclose()
```
```

--------------------------------

### Run performance suite help

Source: https://docs.sqlalchemy.org/en/20/orm/examples.html

Displays the command-line help for the examples.performance package, showing available suites and options.

```bash
$ python -m examples.performance --help
usage: python -m examples.performance [-h] [--test TEST] [--dburl DBURL]
                                      [--num NUM] [--profile] [--dump]
                                      [--echo]

                                      {bulk_inserts,large_resultsets,single_inserts}

positional arguments:
  {bulk_inserts,large_resultsets,single_inserts}
                        suite to run

optional arguments:
  -h, --help            show this help message and exit
  --test TEST           run specific test name
  --dburl DBURL         database URL, default sqlite:///profile.db
  --num NUM             Number of iterations/items/etc for tests;
                        default is module-specific
  --profile             run profiling and dump call counts
  --dump                dump full call profile (implies --profile)
  --echo                Echo SQL output
```

--------------------------------

### Define joined inheritance mappings and insert fixture data

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/_inheritance_setup.html

Defines the Company, Employee, Manager, Engineer, and Paperwork classes using joined table inheritance, creates an in-memory SQLite database, and inserts sample data. Use this setup to follow the inheritance query examples in the ORM Querying Guide.

```python
>>> from typing import List
>>> from sqlalchemy import create_engine
>>> from sqlalchemy import ForeignKey
>>> from sqlalchemy.orm import DeclarativeBase
>>> from sqlalchemy.orm import Mapped
>>> from sqlalchemy.orm import mapped_column
>>> from sqlalchemy.orm import relationship
>>> from sqlalchemy.orm import Session
>>>
>>>
>>> class Base(DeclarativeBase):
...     pass
>>> class Company(Base):
...     __tablename__ = "company"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     name: Mapped[str]
...     employees: Mapped[List["Employee"]] = relationship(back_populates="company")
>>>
>>> class Employee(Base):
...     __tablename__ = "employee"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     name: Mapped[str]
...     type: Mapped[str]
...     company_id: Mapped[int] = mapped_column(ForeignKey("company.id"))
...     company: Mapped[Company] = relationship(back_populates="employees")
...
...     def __repr__(self):
...         return f"{self.__class__.__name__}({self.name!r})"
...
...     __mapper_args__ = {
...         "polymorphic_identity": "employee",
...         "polymorphic_on": "type",
...     }
>>>
>>> class Manager(Employee):
...     __tablename__ = "manager"
...     id: Mapped[int] = mapped_column(ForeignKey("employee.id"), primary_key=True)
...     manager_name: Mapped[str]
...     paperwork: Mapped[List["Paperwork"]] = relationship()
...     __mapper_args__ = {
...         "polymorphic_identity": "manager",
...     }
>>> class Paperwork(Base):
...     __tablename__ = "paperwork"
...     id: Mapped[int] = mapped_column(primary_key=True)
...     manager_id: Mapped[int] = mapped_column(ForeignKey("manager.id"))
...     document_name: Mapped[str]
...
...     def __repr__(self):
...         return f"Paperwork({self.document_name!r})"
>>>
>>> class Engineer(Employee):
...     __tablename__ = "engineer"
...     id: Mapped[int] = mapped_column(ForeignKey("employee.id"), primary_key=True)
...     engineer_info: Mapped[str]
...     __mapper_args__ = {
...         "polymorphic_identity": "engineer",
...     }
>>>
>>> engine = create_engine("sqlite://", echo=True)
>>>
>>> Base.metadata.create_all(engine)
BEGIN ...

>>> conn = engine.connect()
>>> from sqlalchemy.orm import Session
>>> session = Session(conn)
>>> session.add(
...     Company(
...         name="Krusty Krab",
...         employees=[
...             Manager(
...                 name="Mr. Krabs",
...                 manager_name="Eugene H. Krabs",
...                 paperwork=[
...                     Paperwork(document_name="Secret Recipes"),
...                     Paperwork(document_name="Krabby Patty Orders"),
...                 ],
...             ),
...             Engineer(name="SpongeBob", engineer_info="Krabby Patty Master"),
...             Engineer(
...                 name="Squidward",
...                 engineer_info="Senior Customer Engagement Engineer",
...             ),
...         ],
...     )
... )
>>> session.commit()
BEGIN ...
```

--------------------------------

### sessionmaker.begin()

Source: https://docs.sqlalchemy.org/en/20/orm/session_api.html

Produce a context manager that both provides a new Session and begins a transaction.

```APIDOC
## sessionmaker.begin()

### Description
Produce a context manager that both provides a new Session and begins a transaction.

### Method
Context manager

### Endpoint
Not applicable (Python method)

### Parameters
None

### Request Example
```python
with Session.begin() as session:
    session.add(obj)
```

### Response
#### Success Response
Returns a context manager yielding a Session with an active transaction.

#### Response Example
```python
<Session object>
```
```

--------------------------------

### Use istartswith in a select statement

Source: https://docs.sqlalchemy.org/en/20/orm/internals.html

Example of using istartswith to filter rows where a column starts with 'foobar' case-insensitively.

```python
stmt = select(sometable).where(sometable.c.column.istartswith("foobar"))
```

--------------------------------

### async_sessionmaker.__init__()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Initialize the async_sessionmaker.

```APIDOC
## async_sessionmaker.__init__()

### Description
Initialize the async_sessionmaker.

### Method
`__init__(bind=None, **kwargs)`

### Parameters
- **bind** (Engine or Connection, optional) - The engine or connection to bind to.
- **kwargs** - Additional keyword arguments passed to AsyncSession.

### Returns
None
```

--------------------------------

### Engine.begin()

Source: https://docs.sqlalchemy.org/en/20/orm/session_transaction.html

Returns a context manager that begins a transaction on a new Connection, executes statements, and automatically commits or rolls back on exit.

```APIDOC
## Engine.begin()

### Description
Returns a context manager that both procures a new Connection and maintains a begin/commit/rollback context for that Connection. The transaction is committed automatically upon successful exit of the context block, or rolled back if an exception occurs.

### Method
Context manager method on Engine

### Endpoint
Not applicable (Python API)

### Parameters
None

### Returns
A context manager yielding a Connection object with an active transaction.

### Example
```python
engine = create_engine("postgresql+psycopg2://user:pass@host/dbname")

with engine.begin() as conn:
    conn.execute(
        some_table.insert(),
        [
            {"data": "some data one"},
            {"data": "some data two"},
            {"data": "some data three"},
        ],
    )
# commits and closes automatically
```
```

--------------------------------

### Listen for the 'before_flush' event

Source: https://docs.sqlalchemy.org/en/20/orm/events.html

Example argument forms for the SessionEvents.before_flush event listener. Use this to execute logic before the flush process starts.

```python
from sqlalchemy import event


@event.listens_for(SomeSessionClassOrObject, 'before_flush')
def receive_before_flush(session, flush_context, instances):
    "listen for the 'before_flush' event"

    # ... (event handling logic) ...
```

--------------------------------

### ORMExecuteState.__init__()

Source: https://docs.sqlalchemy.org/en/20/orm/session_api.html

Initialize an ORMExecuteState instance.

```APIDOC
## ORMExecuteState.__init__()

### Description
Initialize an ORMExecuteState instance.

### Method
Constructor

### Endpoint
Not applicable (Python method)

### Parameters
- **session** (Session) - The session.
- **statement** (Executable) - The statement being executed.
- **params** (dict) - The parameters.
- **execution_options** (dict) - The execution options.
- **bind_arguments** (dict) - The bind arguments.
- **mapper** (Mapper) - Optional - The mapper.

### Request Example
```python
state = ORMExecuteState(session, statement, params, execution_options, bind_arguments)
```

### Response
#### Success Response
An ORMExecuteState instance.

#### Response Example
```python
<ORMExecuteState object>
```
```

--------------------------------

### Inspect an AliasedClass with inspect()

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/api.html

Use inspect() on an AliasedClass to get an AliasedInsp object. The example assumes MyClass is already mapped and aliased is imported.

```python
from sqlalchemy import inspect

my_alias = aliased(MyClass)
insp = inspect(my_alias)
```

--------------------------------

### Acquire Mapper using inspect()

Source: https://docs.sqlalchemy.org/en/20/orm/mapping_styles.html

Use inspect() from sqlalchemy to get the Mapper for a mapped class. The example assumes a mapped class User is already defined.

```python
>>> from sqlalchemy import inspect
>>> insp = inspect(User)
```

--------------------------------

### Session.begin()

Source: https://docs.sqlalchemy.org/en/20/orm/session_api.html

Begin a transaction on the session.

```APIDOC
## Session.begin()

### Description
Begin a transaction on the session. Returns a SessionTransaction object.

### Method
`begin()`

### Parameters
- None

### Returns
- SessionTransaction
```

--------------------------------

### Inspect an AliasedClass with inspect() and aliased import

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/api.html

Use inspect() on an AliasedClass to get an AliasedInsp object. The example imports both inspect and aliased and assumes MyMappedClass is already mapped.

```python
from sqlalchemy import inspect
from sqlalchemy.orm import aliased

my_alias = aliased(MyMappedClass)
insp = inspect(my_alias)
```

--------------------------------

### Query.slice(start: int, stop: int) -> Self

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/query.html

Computes the “slice” of the Query represented by the given indices and returns the resulting Query. The start and stop indices behave like the argument to Python’s built-in range() function. This method provides an alternative to using LIMIT/OFFSET to get a slice of the query.

```APIDOC
## Query.slice(start: int, stop: int) -> Self

### Description
Computes the “slice” of the `Query` represented by the given indices and returns the resulting `Query`. The start and stop indices behave like the argument to Python’s built-in `range()` function. This method provides an alternative to using `LIMIT`/`OFFSET` to get a slice of the query.

### Method
`slice(start: int, stop: int) -> Self`

### Parameters
- **start** (int) - Required - The starting index.
- **stop** (int) - Required - The stopping index.

### Returns
- **Self** - A new Query object representing the slice.

### Example
```python
session.query(User).order_by(User.id).slice(1, 3)
```

Renders as:
```sql
SELECT users.id AS users_id,
       users.name AS users_name
FROM users ORDER BY users.id
LIMIT ? OFFSET ?
(2, 1)
```

### See Also
- `Query.limit()`
- `Query.offset()`
- `Select.slice()` - v2 equivalent method.
```

--------------------------------

### Session.begin()

Source: https://docs.sqlalchemy.org/en/20/orm/session_transaction.html

Returns a context manager that begins a transaction on a new Session, executes statements, and automatically commits or rolls back on exit.

```APIDOC
## Session.begin()

### Description
Returns a context manager that both procures a new Session and maintains a begin/commit/rollback context for that Session. The transaction is committed automatically upon successful exit of the context block, or rolled back if an exception occurs.

### Method
Context manager method on Session

### Endpoint
Not applicable (Python API)

### Parameters
None

### Returns
A context manager yielding a Session object with an active transaction.

### Example
```python
Session = sessionmaker(engine)

with Session.begin() as session:
    session.add_all(
        [
            SomeClass(data="some data one"),
            SomeClass(data="some data two"),
            SomeClass(data="some data three"),
        ]
    )
# commits and closes automatically
```
```

--------------------------------

### selectinload examples

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/relationships.html

Shows how to use selectinload to eagerly load relationships using SELECT IN. Includes loading a collection, chaining selectinload for nested relationships, and combining lazyload with selectinload.

```python
# selectin-load the "orders" collection on "User"
select(User).options(selectinload(User.orders))

# selectin-load Order.items and then Item.keywords
select(Order).options(
    selectinload(Order.items).selectinload(Item.keywords)
)

# lazily load Order.items, but when Items are loaded,
# selectin-load the keywords collection
select(Order).options(lazyload(Order.items).selectinload(Item.keywords))
```

--------------------------------

### count_from_n_factory

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/orderinglist.html

Factory that creates a numbering function for consecutive integers starting at an arbitrary start value.

```APIDOC
## count_from_n_factory

### Description
Numbering function: consecutive integers starting at arbitrary start.

### Method
Function

### Endpoint
`sqlalchemy.ext.orderinglist.count_from_n_factory(start)`

### Parameters
- **start** (int) - Required - The starting integer for the numbering.

### Returns
Callable[[int, object], int] - A numbering function that returns start + index.
```

--------------------------------

### Run dogpile caching demo modules

Source: https://docs.sqlalchemy.org/en/20/orm/examples.html

Run these commands to execute the demo scripts in order of complexity. The demo creates a local directory for datafiles, inserts initial data, and runs. Running a second time utilizes cache files and emits exactly one SQL statement against two tables.

```shell
$ python -m examples.dogpile_caching.helloworld

$ python -m examples.dogpile_caching.relationship_caching

$ python -m examples.dogpile_caching.advanced

$ python -m examples.dogpile_caching.local_session_caching
```

--------------------------------

### AsyncSession.begin()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Begin a transaction.

```APIDOC
## AsyncSession.begin()

### Description
Begin a transaction.

### Method
`begin()`

### Parameters
None

### Returns
- An AsyncSessionTransaction object.

### Example
```python
async with session.begin():
    # transaction block
    pass
```
```

--------------------------------

### sqlalchemy.ext.orderinglist.count_from_n_factory

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/orderinglist.html

Factory function that returns a numbering function which generates consecutive integers starting at an arbitrary start value.

```APIDOC
## count_from_n_factory

### Description
Numbering function: consecutive integers starting at arbitrary start.

### Signature
```python
sqlalchemy.ext.orderinglist.count_from_n_factory(start: int) -> Callable[[int, Sequence[Any]], object]
```

### Parameters
- **start** (int) - The starting integer for the sequence.

### Returns
- **Callable[[int, Sequence[Any]], object]** - A function that takes an index and a sequence and returns the next integer in the sequence starting from `start`.
```

--------------------------------

### AsyncSession.begin()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Begin a transaction.

```APIDOC
## AsyncSession.begin()

### Description
Begin a transaction.

### Method
Method

### Parameters
None

### Response
- **AsyncTransaction** - A transaction object.
```

--------------------------------

### Define LogRecord ORM mapping with timestamp column

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/dml.html

Example ORM mapping for a LogRecord class with a timestamp column, used in the bulk insert example.

```python
import datetime


class LogRecord(Base):
    __tablename__ = "log_record"
    id: Mapped[int] = mapped_column(primary_key=True)
    message: Mapped[str]
    code: Mapped[str]
    timestamp: Mapped[datetime.datetime]
```

--------------------------------

### Use sessionmaker.begin() for Combined Context

Source: https://docs.sqlalchemy.org/en/20/orm/session_transaction.html

sessionmaker.begin() combines session creation and transaction begin in one context manager, committing on successful exit.

```python
with Session.begin() as session:
    session.add(some_object)
```

--------------------------------

### AsyncSession.__init__()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Initialize an AsyncSession.

```APIDOC
## AsyncSession.__init__()

### Description
Initialize an AsyncSession.

### Method
`__init__(bind=None, binds=None, sync_session_class=Session, **kw)`

### Parameters
- **bind** (Engine or Connection) - Optional - The engine or connection to bind to.
- **binds** (dict) - Optional - A dictionary of binds.
- **sync_session_class** (type) - Optional - The sync session class to use.
- **kw** - Additional keyword arguments.

### Returns
None

### Example
```python
session = AsyncSession(engine)
```
```

--------------------------------

### AsyncSession.__init__()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Initialize an AsyncSession.

```APIDOC
## AsyncSession.__init__()

### Description
Initialize an AsyncSession.

### Method
Method

### Parameters
- **bind** (Engine or Connection) - Optional - The engine or connection to bind.
- **binds** (dict) - Optional - A dictionary of binds.
- **sync_session_class** (type) - Optional - The class to use for the underlying sync session.
- ****kw** - Additional keyword arguments.

### Response
None
```

--------------------------------

### Install SQLAlchemy with Mypy extras using pip

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/mypy.html

Installs SQLAlchemy along with the Mypy dependency using the 'mypy' extras hook. Use this for SQLAlchemy 2.0; ensure sqlalchemy-stubs and sqlalchemy2-stubs are uninstalled.

```bash
pip install sqlalchemy[mypy]
```

--------------------------------

### AsyncEngine.begin()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Return a context manager which when entered will deliver an AsyncConnection with an AsyncTransaction established.

```APIDOC
## AsyncEngine.begin()

### Description
Return a context manager which when entered will deliver an AsyncConnection with an AsyncTransaction established.

### Method
begin()

### Returns
AsyncIterator[AsyncConnection]

### Example
```python
async with async_engine.begin() as conn:
    await conn.execute(
        text("insert into table (x, y, z) values (1, 2, 3)")
    )
    await conn.execute(text("my_special_procedure(5)"))
```
```

--------------------------------

### Subquery Eager Loading Examples with subqueryload

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/relationships.html

Use subqueryload to eagerly load relationships via subqueries. The examples show loading a collection, chaining subqueryload for nested relationships, and combining lazyload with subqueryload.

```python
# subquery-load the "orders" collection on "User"
select(User).options(subqueryload(User.orders))

# subquery-load Order.items and then Item.keywords
select(Order).options(
    subqueryload(Order.items).subqueryload(Item.keywords)
)

# lazily load Order.items, but when Items are loaded,
# subquery-load the keywords collection
select(Order).options(lazyload(Order.items).subqueryload(Item.keywords))
```

--------------------------------

### Example INSERT with RETURNING on PostgreSQL

Source: https://docs.sqlalchemy.org/en/20/orm/persistence_techniques.html

This SQL statement shows the INSERT that SQLAlchemy emits for the MyModel example on PostgreSQL when eager defaults are active. The RETURNING clause includes the primary key and server-default columns.

```sql
INSERT INTO my_table DEFAULT VALUES RETURNING my_table.id, my_table.timestamp, my_table.special_identifier
```

--------------------------------

### AsyncSession.connection()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Get the current connection.

```APIDOC
## AsyncSession.connection()

### Description
Get the current connection.

### Method
`connection()`

### Parameters
None

### Returns
- An AsyncConnection object.

### Example
```python
conn = await session.connection()
```
```

--------------------------------

### Session.__init__()

Source: https://docs.sqlalchemy.org/en/20/orm/session_api.html

Initialize a new Session instance.

```APIDOC
## Session.__init__()

### Description
Initialize a new Session instance with the given parameters.

### Method
`__init__(bind=None, autoflush=True, expire_on_commit=True, ...)`

### Parameters
- **bind** (Engine or Connection) - Optional - The engine or connection to bind to.
- **autoflush** (bool) - Optional - Whether to autoflush before queries.
- **expire_on_commit** (bool) - Optional - Whether to expire objects on commit.

### Returns
- None
```

--------------------------------

### AsyncSession.connection()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Get the current connection.

```APIDOC
## AsyncSession.connection()

### Description
Get the current connection.

### Method
Method

### Parameters
None

### Response
- **AsyncConnection** - The current connection.
```

--------------------------------

### Use select_from() then join()

Source: https://docs.sqlalchemy.org/en/20/orm/queryguide/select.html

Set the initial FROM clause with Select.select_from() so that Select.join() can be used subsequently. The resulting SQL has the same FROM clause as the join_from() examples.

```python
>>> stmt = select(Address).select_from(User).join(Address).where(User.name == "sandy")
>>> print(stmt)
SELECT address.id, address.user_id, address.email_address
FROM user_account JOIN address ON user_account.id = address.user_id
WHERE user_account.name = :name_1
```

--------------------------------

### AsyncTransaction.start()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Starts the transaction. This method is a coroutine.

```APIDOC
## AsyncTransaction.start()

### Description
Starts the transaction. This method is a coroutine.

### Method
`AsyncTransaction.start()`

### Returns
- **None**

### Example
```python
trans = await conn.begin()
await trans.start()
```
```

--------------------------------

### Apply PrimaryKey Generic Type to Integer and UUID Columns

Source: https://docs.sqlalchemy.org/en/20/orm/declarative_tables.html

Shows two mapped classes using the PrimaryKey generic alias: class A gets an Integer primary key, class B gets a UUID primary key.

```python
import uuid


class Base(DeclarativeBase):
    pass


class A(Base):
    __tablename__ = "a"

    # will create an Integer primary key
    id: Mapped[PrimaryKey[int]]


class B(Base):
    __tablename__ = "b"

    # will create a UUID primary key
    id: Mapped[PrimaryKey[uuid.UUID]]
```

--------------------------------

### Run Space Invaders Example

Source: https://docs.sqlalchemy.org/en/20/orm/examples.html

Launch the Space Invaders game using SQLite as the state machine. The game runs in a textual console using ASCII art.

```shell
$ python -m examples.space_invaders.space_invaders
```

--------------------------------

### Create a User Instance with Init-Only Fields

Source: https://docs.sqlalchemy.org/en/20/orm/dataclasses.html

Instantiate User with name, password, and repeat_password. The password_hash is generated in __post_init__ and can be accessed after creation.

```python
>>> u1 = User(name="some_user", password="xyz", repeat_password="xyz")
>>> u1.password_hash
'$6$9ppc... (example hashed string....)'
```

--------------------------------

### sqlalchemy.orm.attributes.get_attribute

Source: https://docs.sqlalchemy.org/en/20/orm/session_api.html

Gets the value of an attribute, firing any callables required.

```APIDOC
## sqlalchemy.orm.attributes.get_attribute

### Description
Get the value of an attribute, firing any callables required.

### Method
get_attribute(instance, key) -> Any

### Parameters
- **instance** - Required - The mapped object instance.
- **key** (str) - Required - The attribute name.

### Returns
- **Any** - The attribute value.

### Example
```python
from sqlalchemy.orm.attributes import get_attribute
value = get_attribute(my_object, 'name')
```
```

--------------------------------

### AsyncEngine.get_execution_options()

Source: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

Get the non-SQL options which will take effect during execution.

```APIDOC
## AsyncEngine.get_execution_options()

### Description
Get the non-SQL options which will take effect during execution.

### Method
get_execution_options()

### Returns
Dict[str, Any]
```

--------------------------------

### sessionmaker.__init__()

Source: https://docs.sqlalchemy.org/en/20/orm/session_api.html

Initialize a sessionmaker instance with the given configuration.

```APIDOC
## sessionmaker.__init__()

### Description
Initialize a sessionmaker instance with the given configuration.

### Method
Constructor

### Endpoint
Not applicable (Python method)

### Parameters
- **bind** (Engine or Connection) - Optional - The engine or connection to bind to.
- **class_** (class) - Optional - The Session class to use. Defaults to Session.
- **autoflush** (bool) - Optional - Whether to autoflush before queries. Defaults to True.
- **autocommit** (bool) - Optional - Whether to use autocommit mode. Defaults to False.
- **expire_on_commit** (bool) - Optional - Whether to expire objects on commit. Defaults to True.
- **\*\*kwargs** - Additional keyword arguments passed to the Session constructor.

### Request Example
```python
Session = sessionmaker(bind=engine, autoflush=False)
```

### Response
#### Success Response
Returns a sessionmaker instance.

#### Response Example
```python
<sessionmaker object>
```
```
Tokens:
Raw