Postgres, step 1: every query numbers its placeholders $1, $2, ... 5d90e0e045e2

        Some(id) => db::issues::milestone(&app.db, id).await?.map(|m| m.title),

        None => None,

    };

    Ok(Issue {

        number: i.number,

        title: i.title.clone(),

        }

        let rows: Vec<(i64, String, String)> = sqlx::query_as(

            "SELECT a.id, a.name, a.hash FROM release_assets a JOIN releases r ON r.id = a.release_id \

        )

        .bind(row.id)

        .fetch_all(&app.db)

// ------------------------------------------------------------- storage

pub async fn list(pool: &Pool, scope: Scope) -> sqlx::Result<Vec<Assistant>> {

        .bind(scope.kind())

        .bind(scope.id())

        .fetch_all(pool)

}

pub async fn get(pool: &Pool, id: i64) -> sqlx::Result<Option<Assistant>> {

}

/// Add an assistant; `None` when the level already has one of that name.

    let now = now_ms();

    let r = sqlx::query_as(

        "INSERT INTO assistants (scope, scope_id, name, endpoint, api, model, headers, token, enabled, budget, created_ms, updated_ms) \

    )

    .bind(scope.kind())

    .bind(scope.id())

pub async fn update(pool: &Pool, id: i64, f: &Fields, token: Option<&[u8]>) -> sqlx::Result<bool> {

    let r = match token {

        Some(t) => sqlx::query(

        )

        .bind(&f.name)

        .bind(&f.endpoint)

        .execute(pool)

        .await?,

        None => sqlx::query(

        )

        .bind(&f.name)

        .bind(&f.endpoint)

    match scope {

        Scope::Site => {

            for table in ["proposal_reviews", "proposal_comments"] {

            }

                .bind(old)

                .bind(new)

                .bind(&like)

                .await?;

        }

        Scope::Org(_) => {

            for table in ["proposal_reviews", "proposal_comments"] {

                    .bind(new)

                    .bind(old)

                    .bind(owner_hint)

                    .execute(pool)

                    .await?;

            }

                .bind(old)

                .bind(new)

                .bind(&like)

                .await?;

        }

        Scope::Repo(id) => {

            for table in ["proposal_reviews", "proposal_comments"] {

                    .bind(new)

                    .bind(old)

                    .bind(id)

                    .execute(pool)

                    .await?;

            }

                .bind(old)

                .bind(new)

                .bind(&like)

}

pub async fn set_enabled(pool: &Pool, id: i64, enabled: bool) -> sqlx::Result<()> {

        .bind(enabled)

        .bind(now_ms())

        .bind(id)

}

pub async fn delete(pool: &Pool, id: i64) -> sqlx::Result<()> {

    Ok(())

}

/// Forget a level's assistants and prompt, when the organisation or

/// repository goes.

pub async fn delete_scope(pool: &Pool, scope: Scope) -> sqlx::Result<()> {

    Ok(())

}

/// The prompt a level adds, empty when none.

pub async fn prompt(pool: &Pool, scope: Scope) -> sqlx::Result<String> {

        .bind(scope.kind())

        .bind(scope.id())

        .fetch_optional(pool)

pub async fn set_prompt(pool: &Pool, scope: Scope, text: &str) -> sqlx::Result<()> {

    if text.trim().is_empty() {

            .bind(scope.kind())

            .bind(scope.id())

            .execute(pool)

            .await?;

    } else {

        sqlx::query(

             ON CONFLICT (scope, scope_id) DO UPDATE SET prompt = excluded.prompt, updated_ms = excluded.updated_ms",

        )

        .bind(scope.kind())

}

pub async fn setting(pool: &Pool, owner: &str) -> sqlx::Result<Option<Setting>> {

}

pub async fn save(pool: &Pool, s: &Setting) -> sqlx::Result<()> {

    sqlx::query(

        "INSERT INTO backup_settings (owner, kind, every, destination, target, prefix, provider, keep_days, updated_ms, region) \

         destination = excluded.destination, target = excluded.target, prefix = excluded.prefix, provider = excluded.provider, \

         keep_days = excluded.keep_days, updated_ms = excluded.updated_ms, region = excluded.region",

    )

}

pub async fn runs(pool: &Pool, owner: &str, limit: i64) -> sqlx::Result<Vec<Run>> {

}

/// What a repository may choose about its backup (§5): with its owner's,

    for s in settings {

        let last = runs(pool, &s.owner, 1).await?.into_iter().next();

        let failed_day: i64 =

                .bind(&s.owner)

                .bind(day_ago)

                .fetch_one(pool)

    }

    let mut out = serde_json::Map::new();

    for (kind, sql) in [

    ] {

        let mut m = serde_json::Map::new();

        for id in ids.get(kind).into_iter().flatten() {

/// The id `name` has on this hub as one of `_names`' kinds.

async fn id_by_name(pool: &Pool, kind: &str, name: &str) -> Result<Option<i64>> {

    Ok(match kind {

        "teams" => match name.split_once('/') {

            Some((org, team)) => {

                    .bind(org)

                    .bind(team)

                    .fetch_optional(pool)

            let sql = format!(

                "{verb} INTO \"{table}\" ({}) VALUES ({})",

                names.iter().map(|n| format!("\"{n}\"")).collect::<Vec<_>>().join(", "),

            );

            let mut q = sqlx::query(&sql);

            for (v, blob) in values {

    // Search finds what came back.

    for (kind, table) in [("issue", "issues"), ("proposal", "proposals")] {

        let found: Vec<(i64, i64, String, String)> =

        for (id, number, title, body) in found {

            db::notify::index(pool, kind, repo, id, number, &title, &body).await?;

        }

    }

    // Webhook secrets were never written: they are entered again.

    let hooks: Vec<String> =

    for url in hooks {

        notes.push(format!("webhook {url}: enter its secret again (Settings › Webhooks)"));

    }

    let s = setting(&app.db, owner).await?.with_context(|| format!("{owner} has no backup set up"))?;

    let started = db::now_ms();

    let at = run_name(started);

    let outcome = run_into(app, &s, &at, trigger == "now").await;

    let (status, detail, sent) = match outcome {

        Ok((sent, problems)) if problems.is_empty() => ("ok", String::new(), sent),

        Ok((sent, problems)) => ("partial", problems.join("; "), sent),

        Err(e) => ("failed", format!("{e:#}"), (0, Sent::default())),

    };

    if status != "ok" {

        notify_failure(app, &s, status, &detail).await;

    } else {

/// The status of `owner`'s finished run before the newest.

async fn status_before(app: &Shared, owner: &str) -> Option<String> {

        .bind(owner)

        .fetch_optional(&app.db)

        .await

    let settings: Vec<Setting> = sqlx::query_as("SELECT * FROM backup_settings WHERE updated_ms > 0").fetch_all(&app.db).await?;

    let mut sent = 0;

    for s in settings {

            .bind(&s.owner)

            .bind(now_ms - 86_400_000)

            .fetch_all(&app.db)

/// "running" by a restart is marked failed first.

pub async fn scheduler(app: Shared) {

    let _ = sqlx::query(

    )

    .bind(db::now_ms())

    .execute(&app.db)

        let theirs: Vec<db::repos::RepoRow> = repos.iter().filter(|r| r.owner == s.owner).cloned().collect();

        let Some(period) = period_with(&s, &theirs) else { continue };

        let last: Option<i64> =

        if last.is_none_or(|l| now - l >= period * 1000) {

            out.push(s);

        }

            .collect();

        if !set.is_empty() {

            let sql = format!(

            );

            let mut q = sqlx::query(&sql);

            for (c, v) in set {

    let sum = |f: &dyn Fn(&FileCoverage) -> u64| kept.iter().map(f).sum::<u64>() as i64;

    let mut tx = crate::db::begin_write(&app.db).await?;

    if let Some(job) = o.job_id {

    }

    let id: i64 = sqlx::query_scalar(

        "INSERT INTO coverage_reports (repo_id, run_id, job_id, job, run_number, bookmark, state, heads, blob, format, \

         lines_found, lines_hit, functions_found, functions_hit, branches_found, branches_hit, hits, files, dropped, created_ms, uploader) \

    )

    .bind(o.repo_id)

    .bind(o.run_id)

    for f in &kept {

        sqlx::query(

            "INSERT INTO coverage_files (report_id, path, lines_found, lines_hit, functions_found, functions_hit, branches_found, branches_hit) \

        )

        .bind(id)

        .bind(&f.path)

}

pub async fn report(pool: &Pool, repo_id: i64, id: i64) -> sqlx::Result<Option<Report>> {

}

/// The newest reports on a bookmark, newest first.

pub async fn on_bookmark(pool: &Pool, repo_id: i64, bookmark: &str, limit: i64) -> sqlx::Result<Vec<Report>> {

        .bind(repo_id)

        .bind(bookmark)

        .bind(limit)

/// When the repository's first report on any bookmark was kept.

pub async fn first_ms(pool: &Pool, repo_id: i64) -> sqlx::Result<Option<i64>> {

}

/// The bookmarks with reports, the most recent first.

pub async fn bookmarks(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<String>> {

        .bind(repo_id)

        .fetch_all(pool)

        .await

pub async fn rules(pool: &Pool, repo_id: i64) -> sqlx::Result<Rules> {

    let row: Option<(Option<f64>, Option<f64>)> =

    Ok(row.map(|(min, max_drop)| Rules { min, max_drop }).unwrap_or_default())

}

pub async fn set_rules(pool: &Pool, repo_id: i64, r: Rules) -> sqlx::Result<()> {

    sqlx::query(

         ON CONFLICT (repo_id) DO UPDATE SET min = excluded.min, max_drop = excluded.max_drop",

    )

    .bind(repo_id)

/// before it there; on any other, the default bookmark's latest before it.

pub async fn baseline(pool: &Pool, r: &Report, default_bookmark: &str) -> sqlx::Result<Option<Report>> {

    sqlx::query_as(

         ORDER BY created_ms DESC, id DESC LIMIT 1",

    )

    .bind(r.repo_id)

}

pub async fn for_run(pool: &Pool, run_id: i64) -> sqlx::Result<Vec<Report>> {

}

pub async fn files(pool: &Pool, report_id: i64) -> sqlx::Result<Vec<FileRow>> {

}

#[cfg(test)]

// ---------------------------------------------------------------- accounts

pub async fn account_by_name(pool: &Pool, username: &str) -> sqlx::Result<Option<Account>> {

}

pub async fn account_by_id(pool: &Pool, id: i64) -> sqlx::Result<Option<Account>> {

}

pub async fn accounts(pool: &Pool) -> sqlx::Result<Vec<Account>> {

    is_admin: bool,

) -> sqlx::Result<Account> {

    sqlx::query_as(

    )

    .bind(username)

    .bind(email)

pub async fn set_profile(pool: &Pool, id: i64, display_name: &str, email: &str) -> sqlx::Result<()> {

    // A changed address is unverified until its own link is used.

    sqlx::query(

    )

    .bind(display_name)

    .bind(email)

/// The public profile fields.

/// The accounts elsewhere a profile shows (#105), already normalised.

pub async fn set_links(pool: &Pool, id: i64, bluesky: &str, mastodon: &str, github: &str) -> sqlx::Result<()> {

        .bind(bluesky)

        .bind(mastodon)

        .bind(github)

}

pub async fn set_bio(pool: &Pool, id: i64, bio: &str, website: &str, location: &str) -> sqlx::Result<()> {

        .bind(bio)

        .bind(website)

        .bind(location)

}

pub async fn set_password(pool: &Pool, id: i64, password_hash: &str, session_salt: &str) -> sqlx::Result<()> {

        .bind(password_hash)

        .bind(session_salt)

        .bind(id)

}

pub async fn set_session_salt(pool: &Pool, id: i64, session_salt: &str) -> sqlx::Result<()> {

    Ok(())

}

pub async fn set_totp(pool: &Pool, id: i64, secret: Option<&str>, recovery_codes: &str) -> sqlx::Result<()> {

        .bind(secret)

        .bind(recovery_codes)

        .bind(id)

}

pub async fn set_admin(pool: &Pool, id: i64, is_admin: bool) -> sqlx::Result<()> {

    Ok(())

}

pub async fn set_banned(pool: &Pool, id: i64, banned: bool) -> sqlx::Result<()> {

    Ok(())

}

pub async fn set_disabled(pool: &Pool, id: i64, disabled: bool) -> sqlx::Result<()> {

    Ok(())

}

/// is retired so nobody can register it and pass for the account.

pub async fn delete_account(pool: &Pool, id: i64, username: &str) -> sqlx::Result<()> {

    let mut tx = super::begin_write(pool).await?;

        .bind(username)

        .bind(now_ms())

        .execute(&mut *tx)

        .await?;

    tx.commit().await

}

pub async fn orgs_owned_only_by(pool: &Pool, account_id: i64) -> sqlx::Result<Vec<String>> {

    sqlx::query_scalar(

        "SELECT o.name FROM organisations o JOIN org_members m ON m.org_id = o.id \

           AND (SELECT COUNT(*) FROM org_members x WHERE x.org_id = o.id AND x.role = 'owner') = 1 \

         ORDER BY o.name",

    )

/// Whether `name` belonged to a deleted account.

pub async fn username_retired(pool: &Pool, name: &str) -> sqlx::Result<bool> {

}

pub async fn touch_seen(pool: &Pool, id: i64) -> sqlx::Result<()> {

    Ok(())

}

// ----------------------------------------------------------- organisations

pub async fn org_by_name(pool: &Pool, name: &str) -> sqlx::Result<Option<Organisation>> {

}

pub async fn orgs(pool: &Pool) -> sqlx::Result<Vec<Organisation>> {

pub async fn orgs_of(pool: &Pool, account_id: i64) -> sqlx::Result<Vec<(Organisation, String)>> {

    let rows: Vec<Membership> = sqlx::query_as(

    )

    .bind(account_id)

    .fetch_all(pool)

pub async fn create_org(pool: &Pool, name: &str, display_name: &str, owner: i64) -> sqlx::Result<Organisation> {

    let mut tx = super::begin_write(pool).await?;

        .bind(name)

        .bind(display_name)

        .bind(now_ms())

        .fetch_one(&mut *tx)

        .await?;

        .bind(org.id)

        .bind(owner)

        .execute(&mut *tx)

}

pub async fn set_org(pool: &Pool, id: i64, display_name: &str, description: &str, default_role: &str) -> sqlx::Result<()> {

        .bind(display_name)

        .bind(description)

        .bind(default_role)

/// `(account, role)` for every member.

pub async fn org_members(pool: &Pool, org_id: i64) -> sqlx::Result<Vec<(Account, String)>> {

    let rows: Vec<(i64, String)> =

    let mut out = Vec::new();

    for (id, role) in rows {

        if let Some(a) = account_by_id(pool, id).await? {

}

pub async fn org_role(pool: &Pool, org_id: i64, account_id: i64) -> sqlx::Result<Option<String>> {

        .bind(org_id)

        .bind(account_id)

        .fetch_optional(pool)

}

pub async fn set_org_member(pool: &Pool, org_id: i64, account_id: i64, role: &str) -> sqlx::Result<()> {

        .bind(org_id)

        .bind(account_id)

        .bind(role)

}

pub async fn remove_org_member(pool: &Pool, org_id: i64, account_id: i64) -> sqlx::Result<()> {

    Ok(())

}

pub async fn teams(pool: &Pool, org_id: i64) -> sqlx::Result<Vec<Team>> {

}

pub async fn team_by_name(pool: &Pool, org_id: i64, name: &str) -> sqlx::Result<Option<Team>> {

}

pub async fn create_team(pool: &Pool, org_id: i64, name: &str) -> sqlx::Result<Team> {

}

pub async fn delete_team(pool: &Pool, id: i64) -> sqlx::Result<()> {

    Ok(())

}

pub async fn team_members(pool: &Pool, team_id: i64) -> sqlx::Result<Vec<Account>> {

        .bind(team_id)

        .fetch_all(pool)

        .await

}

pub async fn add_team_member(pool: &Pool, team_id: i64, account_id: i64) -> sqlx::Result<()> {

        .bind(team_id)

        .bind(account_id)

        .execute(pool)

}

pub async fn remove_team_member(pool: &Pool, team_id: i64, account_id: i64) -> sqlx::Result<()> {

    Ok(())

}

pub async fn assignable(pool: &Pool, repo_id: i64, owner: &str) -> sqlx::Result<Vec<String>> {

    sqlx::query_scalar(

        "SELECT username FROM accounts WHERE banned = 0 AND disabled = 0 AND id IN (\

         ORDER BY username COLLATE NOCASE",

    )

    .bind(owner)

pub async fn collaborators(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<Collaborator>> {

    let rows: Vec<(Option<i64>, Option<i64>, String)> =

    let mut out = Vec::new();

    for (account_id, team_id, role) in rows {

        let account = match account_id {

            None => None,

        };

        let team = match team_id {

            None => None,

        };

        out.push(Collaborator { account, team, role });

pub async fn set_collaborator(pool: &Pool, repo_id: i64, account_id: Option<i64>, team_id: Option<i64>, role: &str) -> sqlx::Result<()> {

    if let Some(a) = account_id {

            .bind(repo_id)

            .bind(a)

            .bind(role)

            .execute(pool)

            .await?;

    } else if let Some(t) = team_id {

            .bind(repo_id)

            .bind(t)

            .bind(role)

}

pub async fn remove_collaborator(pool: &Pool, repo_id: i64, account_id: Option<i64>, team_id: Option<i64>) -> sqlx::Result<()> {

        .bind(repo_id)

        .bind(account_id)

        .bind(team_id)

/// The direct or team role an account holds on a repository, the highest.

pub async fn collaborator_role(pool: &Pool, repo_id: i64, account_id: i64) -> sqlx::Result<Option<String>> {

    let rows: Vec<String> = sqlx::query_scalar(

    )

    .bind(repo_id)

    .bind(account_id)

// ------------------------------------------------------------------ tokens

pub async fn tokens_of(pool: &Pool, account_id: i64) -> sqlx::Result<Vec<Token>> {

}

/// Mark one of `account_id`'s tokens as an agent's, or not.

pub async fn set_token_agent(pool: &Pool, account_id: i64, id: i64, agent: bool) -> sqlx::Result<bool> {

        .bind(agent)

        .bind(id)

        .bind(account_id)

}

pub async fn token_by_hash(pool: &Pool, hash: &str) -> sqlx::Result<Option<Token>> {

}

pub async fn create_token(

    expires_ms: Option<i64>,

) -> sqlx::Result<Token> {

    sqlx::query_as(

    )

    .bind(account_id)

    .bind(name)

}

pub async fn delete_token(pool: &Pool, account_id: i64, id: i64) -> sqlx::Result<()> {

    Ok(())

}

/// Record a use; a renewing token's expiry moves to now plus its lifetime.

pub async fn touch_token(pool: &Pool, id: i64) -> sqlx::Result<()> {

    sqlx::query(

    )

    .bind(now_ms())

    .bind(id)

/// Make a token renewing: it lasts `renew_ms` past its last use.

pub async fn set_token_renewal(pool: &Pool, id: i64, renew_ms: i64) -> sqlx::Result<()> {

    Ok(())

}

    requester: &str,

) -> sqlx::Result<DeviceCode> {

    // Expired codes go whenever a new one is made.

    sqlx::query_as(

    )

    .bind(device_hash)

    .bind(user_code)

}

pub async fn device_by_user_code(pool: &Pool, user_code: &str) -> sqlx::Result<Option<DeviceCode>> {

}

pub async fn device_by_hash(pool: &Pool, device_hash: &str) -> sqlx::Result<Option<DeviceCode>> {

}

/// Approve a pending code for an account with these scopes; false when it

/// was no longer pending.

pub async fn approve_device(pool: &Pool, id: i64, account_id: i64, scopes: &str) -> sqlx::Result<bool> {

    let r = sqlx::query(

    )

    .bind(account_id)

    .bind(scopes)

}

pub async fn deny_device(pool: &Pool, id: i64) -> sqlx::Result<()> {

    Ok(())

}

pub async fn device_polled(pool: &Pool, id: i64) -> sqlx::Result<()> {

    Ok(())

}

/// Remove a code; true when this call removed it (so one poll gets the

/// token, however many race).

pub async fn delete_device(pool: &Pool, id: i64) -> sqlx::Result<bool> {

    Ok(r.rows_affected() == 1)

}

// -------------------------------------------------------------- identities

pub async fn identities_of(pool: &Pool, account_id: i64) -> sqlx::Result<Vec<LinkedIdentity>> {

}

pub async fn identity_by_key(pool: &Pool, key: &str) -> sqlx::Result<Option<LinkedIdentity>> {

}

/// Every linked key with its account's username, for attribution.

}

pub async fn link_identity(pool: &Pool, account_id: i64, key: &str, name: &str, email: &str, object: &[u8]) -> sqlx::Result<()> {

        .bind(key)

        .bind(account_id)

        .bind(name)

}

pub async fn unlink_identity(pool: &Pool, account_id: i64, key: &str) -> sqlx::Result<()> {

    Ok(())

}

pub async fn create_challenge(pool: &Pool, account_id: i64, bytes_hex: &str) -> sqlx::Result<i64> {

        .bind(account_id)

        .bind(bytes_hex)

        .bind(now_ms())

/// Take (and delete) a pending challenge of this account.

pub async fn take_challenge(pool: &Pool, account_id: i64, id: i64) -> sqlx::Result<Option<String>> {

        .bind(id)

        .bind(account_id)

        .bind(now_ms() - 10 * 60 * 1000)

        .fetch_optional(pool)

        .await?;

    Ok(bytes)

}

// ------------------------------------------------------------- invitations

pub async fn create_invitation(pool: &Pool, code: &str, created_by: Option<i64>) -> sqlx::Result<()> {

        .bind(code)

        .bind(created_by)

        .bind(now_ms())

pub async fn invitation_unused(pool: &Pool, code: &str) -> sqlx::Result<bool> {

    let n: i64 =

    Ok(n > 0)

}

/// Use an invitation up if it is still unused; whether it was.

pub async fn claim_invitation(pool: &Pool, code: &str, account_id: i64) -> sqlx::Result<bool> {

        .bind(account_id)

        .bind(code)

        .execute(pool)

}

pub async fn use_invitation(pool: &Pool, code: &str, account_id: i64) -> sqlx::Result<()> {

    Ok(())

}

// ---------------------------------------------------------------- settings

pub async fn setting(pool: &Pool, key: &str) -> sqlx::Result<Option<String>> {

}

pub async fn set_setting(pool: &Pool, key: &str, value: &str) -> sqlx::Result<()> {

        .bind(key)

        .bind(value)

        .execute(pool)

// ------------------------------------------------------------------- audit

pub async fn audit(pool: &Pool, actor: Option<&Account>, action: &str, target: &str, detail: &str) -> sqlx::Result<()> {

        .bind(now_ms())

        .bind(actor.map(|a| a.id))

        .bind(actor.map(|a| a.username.as_str()).unwrap_or(""))

/// A page of the audit log, newest first, older than `before` (an id) when given.

pub async fn audit_page(pool: &Pool, before: Option<i64>, limit: i64) -> sqlx::Result<Vec<AuditRow>> {

        .bind(before)

        .bind(before)

        .bind(limit)

}

pub async fn audit_rows(pool: &Pool, limit: i64) -> sqlx::Result<Vec<AuditRow>> {

        .bind(limit)

        .fetch_all(pool)

        .await

/// its organisations', and those it collaborates on.

pub async fn visible_repo_ids(pool: &Pool, account_id: i64) -> sqlx::Result<Vec<i64>> {

    sqlx::query_scalar(

    )

    .bind(account_id)

    .bind(account_id)

    let secret = crate::auth::random_hex(32);

    let now = now_ms();

    sqlx::query(

    )

    .bind(account_id)

    .bind(kind)

/// An unused, unexpired link of this kind with this secret.

pub async fn live_link(pool: &Pool, kind: &str, secret: &str) -> sqlx::Result<Option<AccountLink>> {

        .bind(kind)

        .bind(crate::auth::token_hash(secret))

        .bind(now_ms())

/// Consume a link; false when it was already used (a race lost).

pub async fn use_link(pool: &Pool, id: i64) -> sqlx::Result<bool> {

    Ok(r.rows_affected() == 1)

}

/// Void every unused link of a kind for an account.

pub async fn void_links(pool: &Pool, account_id: i64, kind: &str) -> sqlx::Result<()> {

        .bind(now_ms())

        .bind(account_id)

        .bind(kind)

pub async fn last_link_ms(pool: &Pool, account_id: i64, kind: &str, email: Option<&str>) -> sqlx::Result<Option<i64>> {

    match email {

        Some(e) => {

                .bind(account_id)

                .bind(kind)

                .bind(e)

                .await

        }

        None => {

                .bind(account_id)

                .bind(kind)

                .fetch_one(pool)

/// How many links of a kind the account got since `since_ms`.

pub async fn links_since(pool: &Pool, account_id: i64, kind: &str, since_ms: i64) -> sqlx::Result<i64> {

        .bind(account_id)

        .bind(kind)

        .bind(since_ms)

}

pub async fn set_email_verified(pool: &Pool, id: i64, verified: bool) -> sqlx::Result<()> {

    Ok(())

}

/// The account with this verified email (case-insensitive), if exactly one.

pub async fn account_by_verified_email(pool: &Pool, email: &str) -> sqlx::Result<Option<Account>> {

        .bind(email)

        .fetch_all(pool)

        .await?;

/// Set or clear the picture of an account (`account`) or organisation (`org`).

pub async fn set_avatar(pool: &Pool, kind: &str, id: i64, value: &str) -> sqlx::Result<()> {

    let table = if kind == "org" { "organisations" } else { "accounts" };

    Ok(())

}

/// Like `feed`, only what `actor` did when one is given (profile pages).

pub async fn feed_by(pool: &Pool, repo_ids: &[i64], actor: Option<&str>, limit: i64) -> sqlx::Result<Vec<Activity>> {

    sqlx::query_as(

           SELECT repo_id, at_ms, pusher AS actor, 'push' AS kind, reference AS event, '' AS title, 0 AS number FROM pushes WHERE ok = 1 \

           UNION ALL SELECT repo_id, created_ms, author, 'release', 'published', tag, 0 FROM releases \

           UNION ALL SELECT p.repo_id, e.at_ms, e.actor, 'proposal', e.event, p.title, p.number FROM proposal_events e JOIN proposals p ON p.id = e.proposal_id \

           UNION ALL SELECT i.repo_id, e.at_ms, e.actor, 'issue', e.event, i.title, i.number FROM issue_events e JOIN issues i ON i.id = e.issue_id) \

         SELECT r.owner, r.name, ev.at_ms, ev.actor, ev.kind, ev.event, ev.title, ev.number \

         FROM ev JOIN repositories r ON r.id = ev.repo_id WHERE ev.repo_id IN (SELECT id FROM seen) \

    )

    .bind(ids_json(repo_ids))