pub struct AgentSkillTool {
pub id: Auto<i64>,
pub skill_id: i64,
pub tool_name: String,
}Expand description
One tool name belonging to a skill.
Fields§
§id: Auto<i64>§skill_id: i64§tool_name: StringImplementations§
Source§impl AgentSkillTool
impl AgentSkillTool
pub const id: id_col = __rustango_cols_AgentSkillTool::id_col
pub const skill_id: skill_id_col = __rustango_cols_AgentSkillTool::skill_id_col
pub const tool_name: tool_name_col = __rustango_cols_AgentSkillTool::tool_name_col
Sourcepub fn objects() -> QuerySet<AgentSkillTool>
pub fn objects() -> QuerySet<AgentSkillTool>
Start a new QuerySet over this model. Django shape.
Sourcepub fn query() -> QuerySet<AgentSkillTool>
pub fn query() -> QuerySet<AgentSkillTool>
Eloquent-shape alias of Self::objects. Returns
a fresh QuerySet<Self> ready for .filter() /
.where_() / etc. Matches Laravel muscle-memory:
// Eloquent: Post::query()->where('published', true)
// Django: Post.objects.filter(published=True)
// rustango: Post::query().filter("published", true)
// or: Post::objects().filter("published", true)Both names point at the same underlying constructor; neither is preferred.
Sourcepub async fn insert(&mut self, pool: &PgPool) -> Result<(), ExecError>
pub async fn insert(&mut self, pool: &PgPool) -> Result<(), ExecError>
Insert this row into its table. Skips columns whose
Auto<T> value is Unset so Postgres’ SERIAL/BIGSERIAL
sequence fills them in, then reads each Auto column
back via RETURNING and stores it on self.
Postgres only — prefer Self::insert_pool. This takes
a driver-specific PgPool, so it does not exist on a build
without the postgres feature. Self::insert_pool takes
rustango::sql::Pool and works on all three. The naming is
inverted; tracked in #1293.
§Errors
Returns [#root::sql::ExecError] for SQL-writing or
driver failures.
Sourcepub async fn insert_on<'_c, _E>(
&mut self,
_executor: _E,
) -> Result<(), ExecError>
pub async fn insert_on<'_c, _E>( &mut self, _executor: _E, ) -> Result<(), ExecError>
Like Self::insert but accepts any sqlx executor.
See Self::save_on for tenancy-scoped rationale.
§Errors
As Self::insert.
Sourcepub async fn insert_on_with<'_c, _E>(
&mut self,
_executor: _E,
source: AuditSource,
) -> Result<(), ExecError>
pub async fn insert_on_with<'_c, _E>( &mut self, _executor: _E, source: AuditSource, ) -> Result<(), ExecError>
Per-call audit-source override for Self::insert_on.
See Self::save_on_with for shape rationale.
§Errors
As Self::insert_on.
Sourcepub async fn bulk_insert(
rows: &mut [Self],
pool: &PgPool,
) -> Result<(), ExecError>
pub async fn bulk_insert( rows: &mut [Self], pool: &PgPool, ) -> Result<(), ExecError>
Bulk-insert rows in a single round-trip. Every row’s
Auto<T> PK fields must uniformly be Auto::Unset
(sequence fills them in) or uniformly Auto::Set(_)
(caller-supplied values). Mixed Set/Unset is rejected
— call insert per row for that case.
Empty slice is a no-op. Each row’s Auto fields are
populated from the RETURNING clause in input order
before this returns.
§Errors
Returns [#root::sql::ExecError] for validation,
SQL-writing, mixed-Auto rejection, or driver failures.
Sourcepub async fn bulk_insert_on<'_c, _E>(
rows: &mut [Self],
_executor: _E,
) -> Result<(), ExecError>
pub async fn bulk_insert_on<'_c, _E>( rows: &mut [Self], _executor: _E, ) -> Result<(), ExecError>
Like Self::bulk_insert but accepts any sqlx executor.
See Self::save_on for tenancy-scoped rationale.
§Errors
Sourcepub async fn bulk_upsert_pool(
rows: &[Self],
target: &[&'static str],
update_cols: &[&'static str],
pool: &Pool,
) -> Result<(), ExecError>
pub async fn bulk_upsert_pool( rows: &[Self], target: &[&'static str], update_cols: &[&'static str], pool: &Pool, ) -> Result<(), ExecError>
Tri-dialect bulk_create(update_conflicts=True) — Django’s
canonical “import a batch idempotently” shape. Issue #267
/ T1.5.
Per-row values are extracted and lowered into a
[#root::core::BulkInsertQuery] with
on_conflict = DoUpdate { target, update_columns }. The
writer dispatches per-dialect:
- Postgres / SQLite:
INSERT … ON CONFLICT (target) DO UPDATE SET col = EXCLUDED.col - MySQL:
INSERT … ON DUPLICATE KEY UPDATE col = VALUES(col)(target ignored — MySQL matches every UNIQUE index)
target names the column(s) whose unique constraint
defines the conflict (typically a unique or
unique_together natural-key column, NOT the Auto<T>
PK). update_cols names the columns to overwrite on
conflict — every other column is left untouched on the
existing row.
Auto-PK rows must all have Auto::Unset (the sequence
picks the PK on insert; the update path never touches
the Auto column). Auto-set rows trigger a hard error.
Empty slice is a no-op.
§Errors
Returns [#root::sql::ExecError] for validation,
SQL-writing, or driver failures.
Sourcepub async fn bulk_insert_or_ignore_pool(
rows: &[Self],
pool: &Pool,
) -> Result<(), ExecError>
pub async fn bulk_insert_or_ignore_pool( rows: &[Self], pool: &Pool, ) -> Result<(), ExecError>
Tri-dialect bulk_create(ignore_conflicts=True) — silently
skip rows that would violate a unique constraint. Issue
#267 / T1.5. Same per-dialect dispatch as
Self::bulk_upsert_pool but with ON CONFLICT … DO NOTHING (Postgres / SQLite) / ON DUPLICATE KEY UPDATE <pivot> = <pivot> (MySQL no-op write).
§Errors
Sourcepub async fn bulk_update(
objs: &[Self],
fields: &[&str],
pool: &Pool,
) -> Result<u64, ExecError>
pub async fn bulk_update( objs: &[Self], fields: &[&str], pool: &Pool, ) -> Result<u64, ExecError>
Django’s QuerySet.bulk_update(objs, fields) — write
per-row-different values for the named fields across
every object in objs in a single statement, matched
by primary key.
fields names the columns to update. The primary
key identifies each row and cannot itself be updated
(pass it and you get
[#root::core::QueryError::BulkUpdatePrimaryKey]).
Empty objs or fields is a no-op returning 0.
Objects whose PK matches no row are simply not updated.
Returns the number of rows affected.
Tri-dialect: lowers to one
[#root::core::BulkUpdateQuery] and dispatches
per-backend — UPDATE … FROM (VALUES …) on Postgres,
a CTE + correlated subquery on SQLite, an inner
JOIN (VALUES …) on MySQL.
§Errors
[#root::core::QueryError::UnknownField] for a name
that isn’t a column on this model,
[#root::core::QueryError::BulkUpdatePrimaryKey] if
fields names the PK, or [#root::sql::ExecError] for
SQL-writing / driver failures.
Sourcepub async fn save(&mut self, pool: &PgPool) -> Result<u64, ExecError>
pub async fn save(&mut self, pool: &PgPool) -> Result<u64, ExecError>
Insert this row if its Auto<T> primary key is
Unset, otherwise update the existing row matching the
PK. Mirrors Django’s save() — caller doesn’t need to
pick insert vs the bulk-update path manually.
On the insert branch, populates the PK from RETURNING
(same behavior as insert). On the update branch,
writes every non-PK column back; if no row matches the
PK, returns Ok(()) silently.
Only generated when the primary key is declared as
Auto<T>. Models with a manually-managed PK must use
insert or the QuerySet update builder.
Postgres only — prefer Self::save_pool. This takes a
driver-specific PgPool, so it does not exist at all on a
build without the postgres feature: selecting sqlite
makes the method vanish rather than fail with anything that
names the cause.
Self::save_pool takes rustango::sql::Pool and works on
all three backends. The naming is inverted — the short name
is the narrow one — and that is tracked in #1293.
§Errors
Returns [#root::sql::ExecError] for SQL-writing
or driver failures.
Sourcepub async fn save_on<'_c, _E>(
&mut self,
_executor: _E,
) -> Result<u64, ExecError>
pub async fn save_on<'_c, _E>( &mut self, _executor: _E, ) -> Result<u64, ExecError>
Like Self::save but accepts any sqlx executor —
&PgPool, &mut PgConnection, or a transaction. The
escape hatch for tenant-scoped writes: schema-mode
tenants share the registry pool but rely on a per-
checkout SET search_path, so passing &PgPool would
silently hit the wrong schema. Acquire a connection
via TenantPools::acquire(&org) and pass &mut *conn.
§Errors
As Self::save.
Sourcepub async fn save_on_with<'_c, _E>(
&mut self,
_executor: _E,
source: AuditSource,
) -> Result<u64, ExecError>
pub async fn save_on_with<'_c, _E>( &mut self, _executor: _E, source: AuditSource, ) -> Result<u64, ExecError>
Per-call override for the audit source. Runs
Self::save_on inside an [#root::audit::with_source]
scope so the resulting audit entry records source
instead of the task-local default. Useful for seed
scripts and one-off CLI tools that don’t sit inside an
admin handler. The override applies only to this call;
no global state changes.
§Errors
As Self::save_on.
Sourcepub async fn upsert(&mut self, pool: &PgPool) -> Result<(), ExecError>
pub async fn upsert(&mut self, pool: &PgPool) -> Result<(), ExecError>
Insert this row or update it in-place if the primary key already
exists — single round-trip via INSERT … ON CONFLICT (pk) DO UPDATE.
With Auto::Unset PK the server assigns a new key and no conflict
can occur (equivalent to insert). With Auto::Set PK the row is
inserted if absent or all non-PK columns are overwritten if present.
§Errors
As Self::insert_on.
Sourcepub async fn upsert_on<'_c, _E>(
&mut self,
_executor: _E,
) -> Result<(), ExecError>
pub async fn upsert_on<'_c, _E>( &mut self, _executor: _E, ) -> Result<(), ExecError>
Like Self::upsert but accepts any sqlx executor.
See Self::save_on for tenancy-scoped rationale.
§Errors
As Self::upsert.
Sourcepub async fn delete(&self, pool: &PgPool) -> Result<u64, ExecError>
pub async fn delete(&self, pool: &PgPool) -> Result<u64, ExecError>
Delete the row identified by this instance’s primary key.
Returns the number of rows affected (0 or 1).
Postgres only — prefer Self::delete_pool. This takes
a driver-specific PgPool, so it does not exist on a build
without the postgres feature. Self::delete_pool takes
rustango::sql::Pool and works on all three. The naming is
inverted; tracked in #1293.
§Errors
Returns [#root::sql::ExecError] for SQL-writing or
driver failures.
Sourcepub async fn delete_on<'_c, _E>(&self, _executor: _E) -> Result<u64, ExecError>
pub async fn delete_on<'_c, _E>(&self, _executor: _E) -> Result<u64, ExecError>
Like Self::delete but accepts any sqlx executor —
for tenant-scoped deletes against an explicitly-acquired
connection. See Self::save_on for the rationale.
§Errors
As Self::delete.
Sourcepub async fn delete_on_with<'_c, _E>(
&self,
_executor: _E,
source: AuditSource,
) -> Result<u64, ExecError>
pub async fn delete_on_with<'_c, _E>( &self, _executor: _E, source: AuditSource, ) -> Result<u64, ExecError>
Per-call audit-source override for Self::delete_on.
See Self::save_on_with for shape rationale.
§Errors
As Self::delete_on.
Sourcepub async fn delete_pool(&self, pool: &Pool) -> Result<u64, ExecError>
pub async fn delete_pool(&self, pool: &Pool) -> Result<u64, ExecError>
Delete the row identified by this instance’s primary key
against either backend. Equivalent to Self::delete but
takes [#root::sql::Pool] and dispatches per backend.
§Errors
As Self::delete.
Sourcepub async fn insert_pool(&mut self, pool: &Pool) -> Result<(), ExecError>
pub async fn insert_pool(&mut self, pool: &Pool) -> Result<(), ExecError>
Insert this row against either backend, populating any
Auto<T> PK from the auto-assigned value.
§Errors
As Self::insert.
Sourcepub async fn insert_or_ignore(&mut self, pool: &Pool) -> Result<bool, ExecError>
pub async fn insert_or_ignore(&mut self, pool: &Pool) -> Result<bool, ExecError>
Eloquent Model::insertOrIgnore() — INSERT this
row or silently skip on unique-constraint
violation. Returns Ok(true) when a row was
inserted, Ok(false) when a conflict caused the
INSERT to silently skip.
Caveat on auto-PK models: when the row is
skipped (conflict), this instance’s Auto<T>
fields stay Unset — no PK is back-populated
because the server didn’t auto-assign one. For
“insert then read back the PK or the existing
row’s PK”, use the upsert family or
get_or_create.
§Errors
As Self::insert.
Sourcepub async fn save_pool(&mut self, pool: &Pool) -> Result<u64, ExecError>
pub async fn save_pool(&mut self, pool: &Pool) -> Result<u64, ExecError>
Save this row to its table against either backend.
INSERT when the Auto<T> PK is Unset, else
UPDATE keyed on the PK.
§Errors
As Self::save.
Sourcepub async fn save_partial(
&mut self,
fields: &[&str],
pool: &Pool,
) -> Result<u64, ExecError>
pub async fn save_partial( &mut self, fields: &[&str], pool: &Pool, ) -> Result<u64, ExecError>
Save (UPDATE) only the listed Rust-side fields,
leaving every other column untouched. Issue #66 —
Django’s Model.save(update_fields=[...]) shape.
fields are Rust-side struct field names; the macro
resolves each to its SQL column. Unknown field
names return [#root::core::QueryError::UnknownField]
wrapped in ExecError::Query. An empty list is a
no-op (returns Ok(()) and logs a tracing::warn!),
matching Django’s “nothing to do” semantic.
Use this when:
- you only mutated a couple of fields on a wide row (avoid re-writing every column on every save), or
- two writers diverged after their initial read and you want to preserve the other writer’s changes to columns you didn’t touch.
Auto-PK models with an unset PK return
[#root::core::QueryError::UnknownField] with
field name <pk> — save_partial is an
UPDATE-only path. Call Self::insert_pool
(or Self::save_pool which dispatches based on
PK state) for the INSERT case.
§Errors
As Self::save_pool, plus UnknownField for
unknown / empty / Auto-Unset cases.
Sourcepub async fn save_partial_typed<L: TypedFieldList<Self>>(
&mut self,
fields: L,
pool: &Pool,
) -> Result<u64, ExecError>
pub async fn save_partial_typed<L: TypedFieldList<Self>>( &mut self, fields: L, pool: &Pool, ) -> Result<u64, ExecError>
Typed-column counterpart of Self::save_partial —
issue #67. fields is a tuple of Column
constants whose Model matches Self; typos and
model mismatches surface at compile time
(Author::name inside a Post::save_partial_typed
call is a type error, no runtime check).
post.save_partial_typed((Post::title, Post::slug), &pool).await?;Lowers to Self::save_partial under the hood — the
tuple is reduced to a &[&str] slice of Rust-side
field names and forwarded.
§Errors
Sourcepub async fn refresh_from_db(&mut self, pool: &Pool) -> Result<(), ExecError>
pub async fn refresh_from_db(&mut self, pool: &Pool) -> Result<(), ExecError>
Re-SELECT this row by its primary key and overwrite
every in-memory field with the freshly-fetched value.
Django’s Model.refresh_from_db. Issue #825.
Use this when the row may have been modified by another process / connection / job since you read it — e.g. after a queued task callback, or to re-sync stale UI state before re-saving.
Returns [ExecError::Driver(sqlx::Error::RowNotFound)]
when the primary key no longer matches any row (e.g.
the row was deleted concurrently).
§Errors
As FetcherPool::fetch; also RowNotFound when
the PK no longer exists.
Sourcepub async fn increment(
&self,
col: &str,
by: i64,
pool: &Pool,
) -> Result<u64, ExecError>
pub async fn increment( &self, col: &str, by: i64, pool: &Pool, ) -> Result<u64, ExecError>
Atomically increment the integer column col by
by for this row. Equivalent to
UPDATE <table> SET <col> = <col> + $1 WHERE <pk> = $2.
Eloquent Model::increment($col, $by) / Django
Model.objects.filter(pk=…).update(col=F('col')+$by)
parity.
Doesn’t mutate self — the in-memory copy is now
stale; call [Self::refresh_from_db_pool] /
[Self::fresh_pool] to re-sync. Returns the rows-
affected count (0 when the PK doesn’t match any row,
1 on success).
col is the Rust field name as a string; unknown
fields surface as UnknownField at runtime. Negative
by values atomically decrement (see also
[Self::decrement_pool]).
§Errors
Sourcepub async fn decrement(
&self,
col: &str,
by: i64,
pool: &Pool,
) -> Result<u64, ExecError>
pub async fn decrement( &self, col: &str, by: i64, pool: &Pool, ) -> Result<u64, ExecError>
Sibling of Self::increment — atomically
decrement this row’s col by by. Eloquent
$model->decrement($col, $by) parity. Equivalent to
self.increment(col, -by, &pool); the separate name
keeps call sites readable.
§Errors
As Self::increment.
Sourcepub async fn increment_each(
col: &str,
by: i64,
pool: &Pool,
) -> Result<u64, ExecError>
pub async fn increment_each( col: &str, by: i64, pool: &Pool, ) -> Result<u64, ExecError>
Bulk-increment: add by to col on every row of the
table. Eloquent Model::query()->increment($col, $by)
parity. Use for counters, score adjustments, view
rollups.
§Errors
Sourcepub async fn fresh(&self, pool: &Pool) -> Result<Option<Self>, ExecError>
pub async fn fresh(&self, pool: &Pool) -> Result<Option<Self>, ExecError>
Re-SELECT this row by its primary key and return a
new instance with the freshly-fetched fields.
Eloquent Model::fresh() parity — non-mutating
counterpart of [Self::refresh_from_db_pool].
Returns Ok(None) when the row was deleted
concurrently — vs [Self::refresh_from_db_pool]
which surfaces that as RowNotFound because
in-place mutation has nothing to write to.
Useful when you want to compare the in-memory instance against the persisted state (audit-style diffs, conflict detection) without mutating the reference you already hold.
§Errors
Sourcepub fn replicate(&self) -> Self
pub fn replicate(&self) -> Self
Eloquent-style replicate() — return a clone of this
row with the primary key reset to Auto::Unset so
the copy is ready for insert_pool / save_pool to
allocate a fresh autoincrement value. Every other
field is Cloned verbatim. Issue #825.
auto_now_add / auto_now timestamp fields are
not reset (Eloquent’s replicate doesn’t reset
them either) — pass them through the normal insert
path if you want fresh values, or assign them
explicitly after the call.
Sourcepub async fn first(pool: &Pool) -> Result<Option<Self>, ExecError>
pub async fn first(pool: &Pool) -> Result<Option<Self>, ExecError>
First row of this model. Eloquent Model::first().
Skipped on models that already declare a field named
first. Drop into QuerySet::<Self>::default().first(&pool).
§Errors
As QuerySet::first.
Sourcepub async fn last(pool: &Pool) -> Result<Option<Self>, ExecError>
pub async fn last(pool: &Pool) -> Result<Option<Self>, ExecError>
Last row of this model by primary-key DESC.
Eloquent Model::query()->latest('id')->first()
parity — fetches the highest-PK row without
requiring the caller to spell the PK column.
Returns None on an empty table.
Equivalent to QuerySet::<Self>::default().last(&pool).
Skipped on models that already declare a field
named last.
§Errors
As QuerySet::last.
Sourcepub async fn first_or_fail(pool: &Pool) -> Result<Self, ExecError>
pub async fn first_or_fail(pool: &Pool) -> Result<Self, ExecError>
Throwing counterpart of [Self::first_pool] —
errors with RowNotFound when the table is empty.
Eloquent Model::firstOrFail() parity.
§Errors
As [Self::first_pool]; additionally
sqlx::Error::RowNotFound on empty tables.
Sourcepub async fn pluck<U>(
col: &'static str,
pool: &Pool,
) -> Result<Vec<U>, ExecError>
pub async fn pluck<U>( col: &'static str, pool: &Pool, ) -> Result<Vec<U>, ExecError>
Single-column projection — `SELECT