Struct HistoricalTask 

pub struct HistoricalTask {
    pub id: i64,
    pub task_id: i64,
    pub status: i32,
    pub saved_at: NaiveDateTime,
}

Historical (Corpus, Service) run records

Fields

id: i64

id of the historical record (task granularity)

task_id: i64

foreign key in Tasks(id)

status: i32

The historical status of the task

saved_at: NaiveDateTime

When was the save request for this historical record made

Implementations

impl HistoricalTask

pub fn retention_stats( connection: &mut PgConnection, ) -> Result<(i64, Option<NaiveDateTime>), Error>

Retention stats for the per-task snapshot store: total rows and the oldest saved_at. This is the unbounded-growth table (one row per task per save-snapshot), so the admin “manage historical data” screen surfaces these to decide a retention cutoff.

pub fn count_before( connection: &mut PgConnection, cutoff: NaiveDateTime, ) -> Result<i64, Error>

How many snapshot rows are strictly older than cutoff — the dry-run count shown before a prune, so the admin sees exactly what a prune would remove.

pub fn prune_before( connection: &mut PgConnection, cutoff: NaiveDateTime, ) -> Result<usize, Error>

Deletes snapshot rows strictly older than cutoff (retention prune), returning the number removed. The run summaries (historical_runs) are untouched — only the bulky per-task snapshots are pruned, so the run history/charts survive while old per-task diffs age out.

pub fn find_by( needle_id: i64, connection: &mut PgConnection, ) -> Result<Vec<Self>, Error>

Obtain all historical records for a given task id

pub fn find_most_recent( needle_id: i64, connection: &mut PgConnection, ) -> Result<Option<HistoricalTask>, Error>

Obtain the most recent historical record for a given taskid

pub fn report_for( corpus: &Corpus, service: &Service, filters: Option<DiffStatusFilter>, connection: &mut PgConnection, ) -> Result<HistoricalReportOverview, Error>

Prepare a report for diffing the two most recent historical records of all tasks belonging to a (corpus,service) pair. We do this 100 tasks at a time, starting from the given offset. The return contract is (id, previous, current)

pub fn status_change_matrix( corpus: &Corpus, service: &Service, previous_date: Option<NaiveDateTime>, current_date: Option<NaiveDateTime>, connection: &mut PgConnection, ) -> Result<StatusChangeMatrix, Error>

The status-transition matrix between two snapshots of a (corpus, service): how many tasks moved from each previous status to each current status. Unlike [report_for], it aggregates in SQL (GROUP BY previous, current), so the result is bounded to one row per status pair (≤ a few dozen) regardless of corpus size — a corpus with two 1.5M-task snapshots is summarized without loading millions of historical_tasks rows into the application (the unbounded-load class of KNOWN_ISSUES R-7/R-8). Returns the available snapshot-date labels (newest first) and the matrix cells (previous_status, current_status, task_count). Fewer than two snapshots (or an out-of-range date pair) yields an empty matrix — a normal “nothing to diff” result, not an error.

Trait Implementations

impl Clone for HistoricalTask

fn clone(&self) -> HistoricalTask

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HistoricalTask

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

Formats the value using the given formatter.

impl Eq for HistoricalTask

impl HasTable for HistoricalTask

type Table = table

The table this type is associated with.

fn table() -> <Self as HasTable>::Table

Returns the table this type is associated with.

impl<'ident> Identifiable for &'ident HistoricalTask

type Id = &'ident i64

The type of this struct’s identifier.

fn id(self) -> <Self as Identifiable>::Id

Returns the identifier for this record.

impl PartialEq for HistoricalTask

fn eq(&self, other: &HistoricalTask) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<__DB: Backend, __ST0, __ST1, __ST2, __ST3> Queryable<(__ST0, __ST1, __ST2, __ST3), __DB> for HistoricalTask

where (i64, i64, i32, NaiveDateTime): FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3), __DB>,

type Row = (i64, i64, i32, NaiveDateTime)

The Rust type you’d like to map from.

fn build(row: (i64, i64, i32, NaiveDateTime)) -> Result<Self>

Construct an instance of this type

impl<__DB: Backend> QueryableByName<__DB> for HistoricalTask

where i64: FromSql<SqlTypeOf<id>, __DB> + FromSql<SqlTypeOf<task_id>, __DB>, i32: FromSql<SqlTypeOf<status>, __DB>, NaiveDateTime: FromSql<SqlTypeOf<saved_at>, __DB>,

fn build<'__a>(row: &impl NamedRow<'__a, __DB>) -> Result<Self>

Construct an instance of Self from the database row

impl StructuralPartialEq for HistoricalTask