Repositories of models (Effect's effect/sql/SqlModel): insert,
update, find and delete a Model.Class's rows::
repo = yield from sql_model.make_repository(
User, table_name="users", span_prefix="UserRepository", id_column="id"
)
user = yield from repo.insert(User.insert.make({"name": "Ada"})) # a Userinsert and update take the model's insert / update variant
(the TypedDicts given to Model.Class) and return the row as the model.
find_by_id and delete take the id, encoded with the id field's
schema (pyright cannot read an attribute's type from a column name, so it
is checked there). With soft_delete_column, delete sets that
column to CURRENT_TIMESTAMP and the reads skip rows where it is set.
make_resolvers gives the same operations as batched resolvers.
insert returns the row through the compiler's returning (RETURNING *, OUTPUT INSERTED.* on SQL Server), and so does update on SQL
Server; elsewhere update appends returning *, as Effect does, so on
ClickHouse only update_void works.
On MySQL both run the statement followed by a SELECT of the row.
Classes#
Functions#
make_repository#
make_repository[A, In, Up](model, *, table_name, span_prefix, id_column, soft_delete_column=None) -> Effect[Repository[A, In, Up], Never, SqlClient]A repository of model on table_name (Effect's
makeRepository); spans are named <span_prefix>.insert and so on.
id_column must be a field of the select and update variants
(ValueError when called).
| Parameter | Type | Description |
|---|---|---|
model | ModelType[A, In, Up] | |
table_name | str | |
span_prefix | str | |
id_column | str | |
soft_delete_column | str | None = None |
Returns Effect[Repository[A, In, Up], Never, SqlClient]
def make_repository[A, In, Up](
model: ModelType[A, In, Up],
*,
table_name: str,
span_prefix: str,
id_column: str,
soft_delete_column: str | None = None,
) -> Effect[Repository[A, In, Up], Never, SqlClient]:
"""A repository of ``model`` on ``table_name`` (Effect's
``makeRepository``); spans are named ``<span_prefix>.insert`` and so on.
``id_column`` must be a field of the ``select`` and ``update`` variants
(``ValueError`` when called)."""
variants = model.__model_variants__()
columns = _columns(variants, table_name, id_column, soft_delete_column)
def build(sql: SqlClientService) -> Repository[A, In, Up]:
return _repository(columns.on(sql), variants, span_prefix)
return SqlClient().map(build)make_resolvers#
make_resolvers[A, In, Up](model, *, table_name, span_prefix, id_column, soft_delete_column=None) -> Effect[Resolvers[A, In], Never, SqlClient]make_repository's insert, insert-without-result, find and delete
as batched resolvers (Effect's makeResolvers): the requests of one
scheduler tick (within one transaction) run as one statement.
| Parameter | Type | Description |
|---|---|---|
model | ModelType[A, In, Up] | |
table_name | str | |
span_prefix | str | |
id_column | str | |
soft_delete_column | str | None = None |
Returns Effect[Resolvers[A, In], Never, SqlClient]
def make_resolvers[A, In, Up](
model: ModelType[A, In, Up],
*,
table_name: str,
span_prefix: str,
id_column: str,
soft_delete_column: str | None = None,
) -> Effect[Resolvers[A, In], Never, SqlClient]:
"""``make_repository``'s insert, insert-without-result, find and delete
as batched resolvers (Effect's ``makeResolvers``): the requests of one
scheduler tick (within one transaction) run as one statement."""
variants = model.__model_variants__()
columns = _columns(variants, table_name, id_column, soft_delete_column)
def build(sql: SqlClientService) -> Resolvers[A, In]:
return _resolvers(columns.on(sql), variants, span_prefix)
return SqlClient().map(build)