Struct PgExperimentChangeRepository 

pub struct PgExperimentChangeRepository { /* private fields */ }

The generated repository.

Implementations

impl PgExperimentChangeRepository

pub fn from_shard(db: &ShardedDb) -> Self

Construct this repository from a ShardedDb extractor, preserving the full request instrumentation — statement timeout, slow-query threshold, and route metric label — from the shard context:

#[post("/bookmarks")]
async fn create(db: ShardedDb, Json(body): Json<Body>) -> AutumnResult<Json<Bookmark>> {
    let repo = BookmarkRepository::from_shard(&db);
    // repo carries the same timeout / slow-query / route label as `db`
    let bookmark = repo.save(&body.into()).await?;
    Ok(Json(bookmark))
}

Read-only methods route to the shard’s read replica when one is configured and healthy (honoring the shard’s replica_fallback policy); mutating methods always use the shard’s primary. Pin a single call chain to the primary with on_primary.

Use this constructor as the standard way to build a repository on a shard; prefer with_pool_untracked only when you intentionally want to bypass request instrumentation.

pub fn with_pool_untracked(pool: Pool<RuntimeConnection>) -> Self

Construct this repository over an explicit pool, bypassing request instrumentation.

Statement timeout, slow-query threshold, and route metric labels are reset to framework defaults (no timeout, 500 ms threshold, no route label). Prefer from_shard when you have a ShardedDb available; use this constructor only when you need an explicit pool without any request context:

let repo = BookmarkRepository::with_pool_untracked(pool.clone());

pub async fn recompute_counter_caches(&self) -> AutumnResult<usize>

Recompute every counter cache this model maintains, for all parent rows, from the source of truth (#1325).

Idempotent: running it twice leaves the same values. Returns the number of parent rows updated, summed across every counter-cached association (0 when the model declares none).

Errors

Propagates any database error from the recompute UPDATEs.

pub async fn recompute_counter_caches_for( &self, parent_id: i64, ) -> AutumnResult<usize>

Recompute every counter cache this model maintains for a single parent row (#1325), leaving every other parent untouched.

Errors

Propagates any database error from the recompute UPDATEs.

pub fn on_primary(&self) -> Self

Returns a clone of this repository whose generated read methods are pinned to the primary pool for the rest of the call chain — the read-your-writes escape hatch (#971).

Use immediately after a write when replication lag would make a replica read stale:

let created = repo.save(&new).await?;
let fresh = repo.on_primary().find_by_id(created.id).await?;

Mutating methods are unaffected — they always run on the primary.

pub fn find_in_batches(&self, batch_size: usize) -> FindInBatches<'_, Self>

Iterate the whole table in bounded-memory chunks of at most batch_size rows, using a primary-key keyset cursor (not LIMIT/OFFSET), so deep iteration stays flat and is stable under concurrent inserts of rows ordered after the current position.

Soft-delete filtering, tenant scoping and read routing match find_all. Drive the returned handle with next_batch() in a while let loop; drop each chunk before requesting the next to hold at most batch_size models at a time.

Iteration ends at the first short batch; rows inserted after that point require a new iteration. Errors are retryable: the cursor only advances on success, so calling next_batch() again after an Err retries the same batch (Ok(None) always means completion). A batch_size of 0 yields an error on every next_batch().

let mut batches = repo.find_in_batches(1_000);
while let Some(chunk) = batches.next_batch().await? {
    repo.upsert_many(&recompute(chunk)).await?;
}

(upsert_many is not generated on repositories with hooks configured; use per-row update there.)

pub fn find_each(&self, batch_size: usize) -> FindEach<'_, Self>

Iterate the whole table one model at a time while still fetching in bounded batch_size chunks — a convenience over find_in_batches.

let mut each = repo.find_each(500);
while let Some(row) = each.next().await? {
    repo.update(row.id, &patch).await?;
}

pub fn count_grouped_by_experiment<'__agg>( &'__agg self, ) -> GroupedAggregate<'__agg, String, i64>

Grouped aggregate count_grouped_by_experiment → lazy GroupedAggregate<'_, K, V> builder (issue #1364).

Chain .order_by_aggregate_desc()/.limit(n) for top-N, .filter_eq(..)/.filter_range(lo, hi) to scope before grouping, or .bucket(DateBucket::Day) for a time series, then .load().await.

pub async fn preload<__Model, __Spec>( &self, records: Vec<__Model>, spec: __Spec, ) -> AutumnResult<Vec<Preloaded<__Model>>>

where __Model: Preloadable<Spec = __Spec>, __Spec: Send + Sync,

Eager-load associations for records returned by a finder.

Wraps each record in Preloaded and loads every association named in spec with at most one batched WHERE ... IN (...) query per association level (plus one per nested level). No per-row fetches, and no implicit lazy loading — an un-preloaded association accessor returns NotLoaded.

Preload SQL runs on the same read role as the finder (the repository’s snapshotted ReadRoute), so a replica-routed list keeps its preloads on the replica.

let posts = repo.find_by_subreddit_id(id).await?;
let posts = repo
    .preload(posts, Post::preload().author().comments_with(Comment::preload().author()))
    .await?;
for post in &posts {
    let author = post.author()?;        // typed accessor
    for comment in post.comments()? { /* ... */ }
}

pub async fn with_lock<F, T>(&self, id: i64, f: F) -> AutumnResult<T>

where F: for<'c> FnOnce(ExperimentChange, &'c mut RuntimeConnection) -> ScopedBoxFuture<'c, 'c, AutumnResult<T>> + Send + 'static, T: Send + 'static,

Pessimistic lock helper: SELECT FOR UPDATE the row with the given id inside a transaction, then call f with the locked record and the transaction connection.

Returns 404 Not Found if no row with id exists.

Trait Implementations

impl BatchSource for PgExperimentChangeRepository

type Model = ExperimentChange

The model type yielded by iteration.

async fn fetch_batch_after( &self, after_id: Option<i64>, limit: i64, ) -> AutumnResult<Vec<ExperimentChange>>

Fetch up to limit models with id > after_id (or from the start of the table when after_id is None), ordered by id ascending.

fn batch_key(model: &ExperimentChange) -> i64

The primary key of a model, used to advance the keyset cursor.

impl Clone for PgExperimentChangeRepository

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ExperimentChangeRepository for PgExperimentChangeRepository

async fn find_by_id(&self, id: i64) -> AutumnResult<Option<ExperimentChange>>

async fn find_all(&self) -> AutumnResult<Vec<ExperimentChange>>

async fn save( &self, new: &NewExperimentChange, ) -> AutumnResult<ExperimentChange>

async fn update( &self, id: i64, changes: &UpdateExperimentChange, ) -> AutumnResult<ExperimentChange>

async fn delete_by_id(&self, id: i64) -> AutumnResult<()>

async fn count(&self) -> AutumnResult<i64>

async fn exists_by_id(&self, id: i64) -> AutumnResult<bool>

async fn page(&self, req: &PageRequest) -> AutumnResult<Page<ExperimentChange>>

Fetch one page of records using offset pagination.

async fn list( &self, query: &ListQuery, req: &PageRequest, ) -> AutumnResult<Page<ExperimentChange>>

Fetch one page of records applying allowlisted sort + equality filters from a ::autumn_web::pagination::ListQuery, with offset pagination from a ::autumn_web::pagination::PageRequest.

async fn list_rows( &self, query: &ListQuery, limit: usize, ) -> AutumnResult<Vec<ExperimentChange>>

Load up to limit records in list order, with the same allowlisted sort, filters and scope.

async fn save_many( &self, new: &[NewExperimentChange], ) -> AutumnResult<Vec<ExperimentChange>>

async fn save_many_skip_invalid( &self, new: &[NewExperimentChange], ) -> AutumnResult<(Vec<ExperimentChange>, Vec<(usize, AutumnError)>)>

async fn update_many( &self, ids: &[i64], changes: &UpdateExperimentChange, ) -> AutumnResult<Vec<ExperimentChange>>

async fn delete_many(&self, ids: &[i64]) -> AutumnResult<()>

Bulk-delete the given ids in one statement.

async fn upsert_many( &self, records: &[ExperimentChange], ) -> AutumnResult<Vec<ExperimentChange>>

where ExperimentChange: Insertable<table>,

impl FromRequestParts<AppState> for PgExperimentChangeRepository

type Rejection = AutumnError

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request_parts( _parts: &mut Parts, state: &AppState, ) -> Result<Self, Self::Rejection>

Perform the extraction.