// Code generated by sqlc. DO NOT EDIT. // versions: // sqlc v1.31.1 // source: schedules.sql package postgresdb import ( "context" "time" "github.com/jackc/pgx/v5/pgtype" ) const deleteSchedule = `-- name: DeleteSchedule :execrows DELETE FROM schedules WHERE id = $1 ` func (q *Queries) DeleteSchedule(ctx context.Context, id string) (int64, error) { result, err := q.db.Exec(ctx, deleteSchedule, id) if err != nil { return 0, err } return result.RowsAffected(), nil } const failStaleRuns = `-- name: FailStaleRuns :exec UPDATE schedule_runs SET result = 'failed', error = 'no result was recorded', finished_at = $1 WHERE result = 'running' AND started_at < $2 ` type FailStaleRunsParams struct { FinishedAt pgtype.Timestamptz StartedAt pgtype.Timestamptz } func (q *Queries) FailStaleRuns(ctx context.Context, arg FailStaleRunsParams) error { _, err := q.db.Exec(ctx, failStaleRuns, arg.FinishedAt, arg.StartedAt) return err } const finishScheduleRun = `-- name: FinishScheduleRun :one UPDATE schedule_runs SET result = $2, error = $3, finished_at = $4 WHERE id = $1 AND result = 'running' RETURNING schedule_id ` type FinishScheduleRunParams struct { ID int64 Result string Error string FinishedAt pgtype.Timestamptz } func (q *Queries) FinishScheduleRun(ctx context.Context, arg FinishScheduleRunParams) (string, error) { row := q.db.QueryRow(ctx, finishScheduleRun, arg.ID, arg.Result, arg.Error, arg.FinishedAt, ) var schedule_id string err := row.Scan(&schedule_id) return schedule_id, err } const getSchedule = `-- name: GetSchedule :one SELECT id, owner_kind, owner_id, name, enabled, built_in, timing_kind, interval_seconds, cron, run_at, anchor, next_run, zone, created_at, updated_at FROM schedules WHERE id = $1 ` func (q *Queries) GetSchedule(ctx context.Context, id string) (Schedule, error) { row := q.db.QueryRow(ctx, getSchedule, id) var i Schedule err := row.Scan( &i.ID, &i.OwnerKind, &i.OwnerID, &i.Name, &i.Enabled, &i.BuiltIn, &i.TimingKind, &i.IntervalSeconds, &i.Cron, &i.RunAt, &i.Anchor, &i.NextRun, &i.Zone, &i.CreatedAt, &i.UpdatedAt, ) return i, err } const insertBuiltinSchedule = `-- name: InsertBuiltinSchedule :exec INSERT INTO schedules (id, owner_kind, owner_id, name, enabled, built_in, timing_kind, interval_seconds, anchor, next_run, zone) VALUES ($1, 'instance', '', $2, true, true, 'interval', $3, $4, $5, $6) ON CONFLICT (id) DO NOTHING ` type InsertBuiltinScheduleParams struct { ID string Name string IntervalSeconds int64 Anchor time.Time NextRun pgtype.Timestamptz Zone string } func (q *Queries) InsertBuiltinSchedule(ctx context.Context, arg InsertBuiltinScheduleParams) error { _, err := q.db.Exec(ctx, insertBuiltinSchedule, arg.ID, arg.Name, arg.IntervalSeconds, arg.Anchor, arg.NextRun, arg.Zone, ) return err } const insertScheduleRun = `-- name: InsertScheduleRun :one INSERT INTO schedule_runs (schedule_id, scheduled_for, started_at, result) VALUES ($1, $2, $3, $4) ON CONFLICT (schedule_id, scheduled_for) DO NOTHING RETURNING id, schedule_id, scheduled_for, started_at, finished_at, result, error, capture_id ` type InsertScheduleRunParams struct { ScheduleID string ScheduledFor time.Time StartedAt pgtype.Timestamptz Result string } func (q *Queries) InsertScheduleRun(ctx context.Context, arg InsertScheduleRunParams) (ScheduleRun, error) { row := q.db.QueryRow(ctx, insertScheduleRun, arg.ScheduleID, arg.ScheduledFor, arg.StartedAt, arg.Result, ) var i ScheduleRun err := row.Scan( &i.ID, &i.ScheduleID, &i.ScheduledFor, &i.StartedAt, &i.FinishedAt, &i.Result, &i.Error, &i.CaptureID, ) return i, err } const latestScheduleRuns = `-- name: LatestScheduleRuns :many SELECT DISTINCT ON (schedule_id) id, schedule_id, scheduled_for, started_at, finished_at, result, error, capture_id FROM schedule_runs ORDER BY schedule_id, scheduled_for DESC ` func (q *Queries) LatestScheduleRuns(ctx context.Context) ([]ScheduleRun, error) { rows, err := q.db.Query(ctx, latestScheduleRuns) if err != nil { return nil, err } defer rows.Close() var items []ScheduleRun for rows.Next() { var i ScheduleRun if err := rows.Scan( &i.ID, &i.ScheduleID, &i.ScheduledFor, &i.StartedAt, &i.FinishedAt, &i.Result, &i.Error, &i.CaptureID, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const listScheduleRuns = `-- name: ListScheduleRuns :many SELECT id, schedule_id, scheduled_for, started_at, finished_at, result, error, capture_id FROM schedule_runs WHERE schedule_id = $1 ORDER BY scheduled_for DESC LIMIT $2 ` type ListScheduleRunsParams struct { ScheduleID string Limit int32 } func (q *Queries) ListScheduleRuns(ctx context.Context, arg ListScheduleRunsParams) ([]ScheduleRun, error) { rows, err := q.db.Query(ctx, listScheduleRuns, arg.ScheduleID, arg.Limit) if err != nil { return nil, err } defer rows.Close() var items []ScheduleRun for rows.Next() { var i ScheduleRun if err := rows.Scan( &i.ID, &i.ScheduleID, &i.ScheduledFor, &i.StartedAt, &i.FinishedAt, &i.Result, &i.Error, &i.CaptureID, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const listSchedules = `-- name: ListSchedules :many SELECT id, owner_kind, owner_id, name, enabled, built_in, timing_kind, interval_seconds, cron, run_at, anchor, next_run, zone, created_at, updated_at FROM schedules ORDER BY built_in, name, id ` // Schedules and their runs (internal/domain/scheduling). func (q *Queries) ListSchedules(ctx context.Context) ([]Schedule, error) { rows, err := q.db.Query(ctx, listSchedules) if err != nil { return nil, err } defer rows.Close() var items []Schedule for rows.Next() { var i Schedule if err := rows.Scan( &i.ID, &i.OwnerKind, &i.OwnerID, &i.Name, &i.Enabled, &i.BuiltIn, &i.TimingKind, &i.IntervalSeconds, &i.Cron, &i.RunAt, &i.Anchor, &i.NextRun, &i.Zone, &i.CreatedAt, &i.UpdatedAt, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const lockDueSchedules = `-- name: LockDueSchedules :many SELECT id, owner_kind, owner_id, name, enabled, built_in, timing_kind, interval_seconds, cron, run_at, anchor, next_run, zone, created_at, updated_at FROM schedules WHERE enabled AND next_run IS NOT NULL AND next_run <= $1 ORDER BY next_run FOR UPDATE SKIP LOCKED ` func (q *Queries) LockDueSchedules(ctx context.Context, nextRun pgtype.Timestamptz) ([]Schedule, error) { rows, err := q.db.Query(ctx, lockDueSchedules, nextRun) if err != nil { return nil, err } defer rows.Close() var items []Schedule for rows.Next() { var i Schedule if err := rows.Scan( &i.ID, &i.OwnerKind, &i.OwnerID, &i.Name, &i.Enabled, &i.BuiltIn, &i.TimingKind, &i.IntervalSeconds, &i.Cron, &i.RunAt, &i.Anchor, &i.NextRun, &i.Zone, &i.CreatedAt, &i.UpdatedAt, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const lockSchedule = `-- name: LockSchedule :one SELECT id, owner_kind, owner_id, name, enabled, built_in, timing_kind, interval_seconds, cron, run_at, anchor, next_run, zone, created_at, updated_at FROM schedules WHERE id = $1 FOR UPDATE ` func (q *Queries) LockSchedule(ctx context.Context, id string) (Schedule, error) { row := q.db.QueryRow(ctx, lockSchedule, id) var i Schedule err := row.Scan( &i.ID, &i.OwnerKind, &i.OwnerID, &i.Name, &i.Enabled, &i.BuiltIn, &i.TimingKind, &i.IntervalSeconds, &i.Cron, &i.RunAt, &i.Anchor, &i.NextRun, &i.Zone, &i.CreatedAt, &i.UpdatedAt, ) return i, err } const lockStaleZoneCronSchedules = `-- name: LockStaleZoneCronSchedules :many SELECT id, owner_kind, owner_id, name, enabled, built_in, timing_kind, interval_seconds, cron, run_at, anchor, next_run, zone, created_at, updated_at FROM schedules WHERE enabled AND timing_kind = 'cron' AND zone <> $1 FOR UPDATE SKIP LOCKED ` func (q *Queries) LockStaleZoneCronSchedules(ctx context.Context, zone string) ([]Schedule, error) { rows, err := q.db.Query(ctx, lockStaleZoneCronSchedules, zone) if err != nil { return nil, err } defer rows.Close() var items []Schedule for rows.Next() { var i Schedule if err := rows.Scan( &i.ID, &i.OwnerKind, &i.OwnerID, &i.Name, &i.Enabled, &i.BuiltIn, &i.TimingKind, &i.IntervalSeconds, &i.Cron, &i.RunAt, &i.Anchor, &i.NextRun, &i.Zone, &i.CreatedAt, &i.UpdatedAt, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const pruneScheduleRuns = `-- name: PruneScheduleRuns :execrows WITH ranked AS ( SELECT id AS run_id, finished_at AS ended, row_number() OVER (PARTITION BY schedule_id ORDER BY scheduled_for DESC) AS position FROM schedule_runs WHERE result NOT IN ('pending', 'running') ) DELETE FROM schedule_runs WHERE id IN ( SELECT run_id FROM ranked WHERE ended < $1::timestamptz OR position > $2::bigint ) ` type PruneScheduleRunsParams struct { Before time.Time Keep int64 } func (q *Queries) PruneScheduleRuns(ctx context.Context, arg PruneScheduleRunsParams) (int64, error) { result, err := q.db.Exec(ctx, pruneScheduleRuns, arg.Before, arg.Keep) if err != nil { return 0, err } return result.RowsAffected(), nil } const recentFinishedResults = `-- name: RecentFinishedResults :many SELECT result FROM schedule_runs WHERE schedule_id = $1 AND result IN ('succeeded', 'failed') ORDER BY scheduled_for DESC LIMIT $2 ` type RecentFinishedResultsParams struct { ScheduleID string Limit int32 } func (q *Queries) RecentFinishedResults(ctx context.Context, arg RecentFinishedResultsParams) ([]string, error) { rows, err := q.db.Query(ctx, recentFinishedResults, arg.ScheduleID, arg.Limit) if err != nil { return nil, err } defer rows.Close() var items []string for rows.Next() { var result string if err := rows.Scan(&result); err != nil { return nil, err } items = append(items, result) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const setScheduleNextRun = `-- name: SetScheduleNextRun :exec UPDATE schedules SET next_run = $2, zone = $3 WHERE id = $1 ` type SetScheduleNextRunParams struct { ID string NextRun pgtype.Timestamptz Zone string } func (q *Queries) SetScheduleNextRun(ctx context.Context, arg SetScheduleNextRunParams) error { _, err := q.db.Exec(ctx, setScheduleNextRun, arg.ID, arg.NextRun, arg.Zone) return err } const setScheduleRunCapture = `-- name: SetScheduleRunCapture :execrows UPDATE schedule_runs SET capture_id = $2 WHERE id = $1 ` type SetScheduleRunCaptureParams struct { ID int64 CaptureID string } func (q *Queries) SetScheduleRunCapture(ctx context.Context, arg SetScheduleRunCaptureParams) (int64, error) { result, err := q.db.Exec(ctx, setScheduleRunCapture, arg.ID, arg.CaptureID) if err != nil { return 0, err } return result.RowsAffected(), nil } const startRequestedRuns = `-- name: StartRequestedRuns :many UPDATE schedule_runs r SET result = 'running', started_at = $1 FROM schedules s WHERE r.result = 'pending' AND s.id = r.schedule_id RETURNING r.id, r.schedule_id, r.scheduled_for, s.name, s.built_in, s.owner_id ` type StartRequestedRunsRow struct { ID int64 ScheduleID string ScheduledFor time.Time Name string BuiltIn bool OwnerID string } func (q *Queries) StartRequestedRuns(ctx context.Context, startedAt pgtype.Timestamptz) ([]StartRequestedRunsRow, error) { rows, err := q.db.Query(ctx, startRequestedRuns, startedAt) if err != nil { return nil, err } defer rows.Close() var items []StartRequestedRunsRow for rows.Next() { var i StartRequestedRunsRow if err := rows.Scan( &i.ID, &i.ScheduleID, &i.ScheduledFor, &i.Name, &i.BuiltIn, &i.OwnerID, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Err(); err != nil { return nil, err } return items, nil } const upsertSchedule = `-- name: UpsertSchedule :one INSERT INTO schedules (id, owner_kind, owner_id, name, enabled, built_in, timing_kind, interval_seconds, cron, run_at, anchor, next_run, zone) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) ON CONFLICT (id) DO UPDATE SET owner_kind = excluded.owner_kind, owner_id = excluded.owner_id, name = excluded.name, enabled = excluded.enabled, timing_kind = excluded.timing_kind, interval_seconds = excluded.interval_seconds, cron = excluded.cron, run_at = excluded.run_at, anchor = excluded.anchor, next_run = excluded.next_run, zone = excluded.zone, updated_at = now() RETURNING id, owner_kind, owner_id, name, enabled, built_in, timing_kind, interval_seconds, cron, run_at, anchor, next_run, zone, created_at, updated_at ` type UpsertScheduleParams struct { ID string OwnerKind string OwnerID string Name string Enabled bool BuiltIn bool TimingKind string IntervalSeconds int64 Cron string RunAt pgtype.Timestamptz Anchor time.Time NextRun pgtype.Timestamptz Zone string } func (q *Queries) UpsertSchedule(ctx context.Context, arg UpsertScheduleParams) (Schedule, error) { row := q.db.QueryRow(ctx, upsertSchedule, arg.ID, arg.OwnerKind, arg.OwnerID, arg.Name, arg.Enabled, arg.BuiltIn, arg.TimingKind, arg.IntervalSeconds, arg.Cron, arg.RunAt, arg.Anchor, arg.NextRun, arg.Zone, ) var i Schedule err := row.Scan( &i.ID, &i.OwnerKind, &i.OwnerID, &i.Name, &i.Enabled, &i.BuiltIn, &i.TimingKind, &i.IntervalSeconds, &i.Cron, &i.RunAt, &i.Anchor, &i.NextRun, &i.Zone, &i.CreatedAt, &i.UpdatedAt, ) return i, err }