Struct CounterCacheSpec 

pub struct CounterCacheSpec<M: 'static> {

    pub child_table: &'static str,
    pub child_pk: &'static str,
    pub child_soft_delete: bool,
    pub fk_column: &'static str,
    pub parent_table: &'static str,
    pub parent_pk: &'static str,
    pub counter_column: &'static str,
    pub fk_of: fn(&M) -> Option<i64>,
    pub pk_of: fn(&M) -> i64,
    pub live_of: fn(&M) -> bool,
    pub tenant_column: Option<&'static str>,
    pub tenant_of: Option<fn(&M) -> Option<String>>,
    pub contrib_of: fn(&M) -> i64,
    pub contrib_sql: &'static str,
    pub filter_sql: &'static str,
    pub derivation: Option<&'static DerivationDef>,
}

One counter-cached belongs_to leg, produced at compile time by #[model] and consulted at run time by the child’s generated repository.

Framework plumbing; not constructed by hand.

Fields

child_table: &'static str

The child’s table, e.g. comments.

child_pk: &'static str

The child’s primary-key column, e.g. id.

child_soft_delete: bool

Whether the child model carries a deleted_at column. When true the count reflects live rows only: the decrement is scoped to a live child (so a second soft delete moves nothing) and the recompute filters soft-deleted rows out.

fk_column: &'static str

The child’s foreign-key column pointing at the parent, e.g. post_id.

parent_table: &'static str

The parent’s table, e.g. posts.

parent_pk: &'static str

The parent’s primary-key column, e.g. id.

counter_column: &'static str

The maintained column on the parent, e.g. comment_count.

fk_of: fn(&M) -> Option<i64>

Reads this leg’s foreign key off a child record. None for a nullable foreign key that is unset — an unparented child moves no counter.

pk_of: fn(&M) -> i64

Reads the child’s own primary key off a record. Used by the bulk paths to match a post-update record back to the foreign keys captured for it before the update, and to scope the tenant predicate below.

live_of: fn(&M) -> bool

Whether a record is live (not soft-deleted). Always true for a child with no deleted_at column.

The generated update does not filter soft-deleted rows, so an already-deleted child can be re-parented. It is counted by nobody, so neither its old nor its new parent may move — without this the update would decrement a parent that had already dropped it and increment one for a dead row.

tenant_column: Option<&'static str>

The tenant-discriminator column, from #[belongs_to(…, counter_cache, counter_cache_tenant = "<column>")].

A counter update is a write to a row the caller only had to name the id of, so on a shared multi-tenant table it has to be confined to the caller’s own tenant — the same hazard #[votable]’s aggregate UPDATE is scoped for. The predicate spells the invariant “the parent sits in the same tenant as the child whose foreign key named it”, so both tables must carry a column of this name. That is why it is explicit: #[model] on the child cannot see the parent’s fields, and guessing would turn every tenant-scoped child hanging off a global parent into a hard column does not exist.

None (the default) emits no predicate anywhere, so a single-tenant app’s SQL is byte-for-byte what it would be without this field.

tenant_of: Option<fn(&M) -> Option<String>>

Reads the child’s tenant discriminator off a record, as text, the way the database spells CAST(<tenant> AS TEXT).

Some only for a leg with a Self::tenant_column whose child model carries that field as an integer or string. Then the pre-update capture reads the old tenant too, and a child moved to another tenant takes its contribution off the old parent under the old tenant: the live predicate would look for the parent under the new one and miss it. None keeps the leg’s SQL exactly as it was.

contrib_of: fn(&M) -> i64

This row’s weight in the maintained aggregate. 0 excludes the row.

A plain counter cache returns 1 for every row; a #[derivation] returns 0 when its filter rejects the row, and otherwise 1 (a count) or the summed field’s value (a sum).

contrib_sql: &'static str

The SQL half of Self::contrib_of, for the set-based paths.

"1" for a counter cache, else a child column reference such as {c}."score". {c} is the placeholder for whichever alias the statement gives the child table.

filter_sql: &'static str

The derivation’s row filter, lowered to SQL and already prefixed with AND so any builder can concatenate it.

"" for a counter cache, which is what keeps a counter cache’s generated SQL byte-identical. Else AND (<pred>), using the same {c} child-alias placeholder as Self::contrib_sql.

derivation: Option<&'static DerivationDef>

The #[derivation] this spec maintains, or None for a plain counter cache. It carries the metadata the backfill and status surfaces read.

Trait Implementations

impl<M: 'static> Clone for CounterCacheSpec<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<M: 'static> Copy for CounterCacheSpec<M>

impl<M: Debug + 'static> Debug for CounterCacheSpec<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.