Struct Sequence 

pub struct Sequence { /* private fields */ }

The uniqueness source: a process-unique, time-derived base plus an atomic counter. Generated factory modules hold one per model:

static SEQ: Sequence = Sequence::new();
// …
id: self.id.resolve(f, |_| Set::Value(SEQ.next_i64())),

Two promises, in order of strength:

• In-process, values never repeat — the counter is atomic, so create_many(&db, 100) (and every factory call across every test in the binary) draws distinct values.
• Across processes, collision is improbable — the base is taken from the clock at first use (the same shape the Layer 2 spec’s key() pinned), so runs against a shared persistent server land in different ranges. Improbable, not impossible: this is test-data machinery, not a coordination service.

Values are positive and fit i32, so the one sequence serves integer (PostgreSQL/MySQL) and INTEGER (SQLite) primary keys alike.

Deliberately outside the Faker seed: sequences exist for uniqueness, and a reproducible primary key against a shared server would reproduce a collision (crate docs, “the determinism switch”).

Implementations

impl Sequence

pub const fn new() -> Self

A fresh sequence; const, so it can be a static in a generated module. The base is drawn from the clock on first use, not here.

pub fn next_i32(&self) -> i32

The next value, i32-typed for dialects whose integer is 32-bit.

pub fn next_i64(&self) -> i64

The next value, widened — the same counter as next_i32, for i64-typed columns.

Trait Implementations

impl Debug for Sequence

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

Formats the value using the given formatter.

impl Default for Sequence

fn default() -> Self

Returns the “default value” for a type.