Files
archie/internal/infrastructure/postgres/postgresdb/events.sql.go
T
sam c833081544 feat(postgres): port events/identities/status surfaces, fix shipped defects
CHECKPOINT -- the full State Store port is in progress; this lands the
compile-clean core so the review pass has a diff to work against. Remaining:
advisory-lock ownership, event-insert serialization, maintenance, and the
ported test battery.

Two corrections to behaviour that already shipped, not new features:
- UpdateTask wrote park_reason raw where SQLite applies clip(park_reason,
  4000); the PostgreSQL adapter now clips before binding (clip.go).
- tasks.review_cursor existed on the protobuf wire and in workflow.Task but
  not in the PostgreSQL schema; 0004 adds it as a NEW migration rather than
  amending 0001 because a dev database may already have applied 0001 and
  goose tracks version numbers, not checksums.

Also moves the control-plane Resource/ResourceWrite types and their sentinels
into storecontract so the postgres package can stop importing internal/store
(they stay aliased there for daemon callers).
2026-09-24 02:17:44 +10:00

340 lines
7.4 KiB
Go

// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: events.sql
package postgresdb
import (
"context"
"time"
)
const insertEvent = `-- name: InsertEvent :one
INSERT INTO events (at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
RETURNING id
`
type InsertEventParams struct {
At time.Time
Kind string
TaskID int64
Repo string
Issue int64
Workflow string
Stage string
Attempt int64
ActorID string
ActorKind string
PrincipalID string
Detail string
Data string
}
// Event-log queries. The (at, id) cursor is a wire contract: at is the
// fixed-width sort key and id only breaks ties, so a reader pages by
// "after (at, id)" and never skips or repeats a row. See
// internal/domain/storecontract/cursor.go.
func (q *Queries) InsertEvent(ctx context.Context, arg InsertEventParams) (int64, error) {
row := q.db.QueryRow(ctx, insertEvent,
arg.At,
arg.Kind,
arg.TaskID,
arg.Repo,
arg.Issue,
arg.Workflow,
arg.Stage,
arg.Attempt,
arg.ActorID,
arg.ActorKind,
arg.PrincipalID,
arg.Detail,
arg.Data,
)
var id int64
err := row.Scan(&id)
return id, err
}
const listEventsAfter = `-- name: ListEventsAfter :many
SELECT id, at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data
FROM events
WHERE at > $1 OR (at = $1 AND id > $2)
ORDER BY at, id
LIMIT $3
`
type ListEventsAfterParams struct {
At time.Time
ID int64
Limit int32
}
func (q *Queries) ListEventsAfter(ctx context.Context, arg ListEventsAfterParams) ([]Event, error) {
rows, err := q.db.Query(ctx, listEventsAfter, arg.At, arg.ID, arg.Limit)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Event
for rows.Next() {
var i Event
if err := rows.Scan(
&i.ID,
&i.At,
&i.Kind,
&i.TaskID,
&i.Repo,
&i.Issue,
&i.Workflow,
&i.Stage,
&i.Attempt,
&i.ActorID,
&i.ActorKind,
&i.PrincipalID,
&i.Detail,
&i.Data,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listEventsFromBeginning = `-- name: ListEventsFromBeginning :many
SELECT id, at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data
FROM events
ORDER BY at, id
LIMIT $1
`
func (q *Queries) ListEventsFromBeginning(ctx context.Context, limit int32) ([]Event, error) {
rows, err := q.db.Query(ctx, listEventsFromBeginning, limit)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Event
for rows.Next() {
var i Event
if err := rows.Scan(
&i.ID,
&i.At,
&i.Kind,
&i.TaskID,
&i.Repo,
&i.Issue,
&i.Workflow,
&i.Stage,
&i.Attempt,
&i.ActorID,
&i.ActorKind,
&i.PrincipalID,
&i.Detail,
&i.Data,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const stageStats = `-- name: StageStats :many
SELECT workflow, stage,
COUNT(*)::int AS runs,
CAST(AVG((data::jsonb ->> 'duration_ms')::numeric) AS bigint) AS avg_ms,
COUNT(*) FILTER (WHERE (data::jsonb ->> 'error') IS NOT NULL)::int AS errors
FROM events
WHERE kind = 'stage_finish'
GROUP BY workflow, stage
ORDER BY workflow, stage
`
type StageStatsRow struct {
Workflow string
Stage string
Runs int32
AvgMs int64
Errors int32
}
func (q *Queries) StageStats(ctx context.Context) ([]StageStatsRow, error) {
rows, err := q.db.Query(ctx, stageStats)
if err != nil {
return nil, err
}
defer rows.Close()
var items []StageStatsRow
for rows.Next() {
var i StageStatsRow
if err := rows.Scan(
&i.Workflow,
&i.Stage,
&i.Runs,
&i.AvgMs,
&i.Errors,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const taskEventsByID = `-- name: TaskEventsByID :many
SELECT id, at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data
FROM events
WHERE task_id = $1
ORDER BY id
`
func (q *Queries) TaskEventsByID(ctx context.Context, taskID int64) ([]Event, error) {
rows, err := q.db.Query(ctx, taskEventsByID, taskID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Event
for rows.Next() {
var i Event
if err := rows.Scan(
&i.ID,
&i.At,
&i.Kind,
&i.TaskID,
&i.Repo,
&i.Issue,
&i.Workflow,
&i.Stage,
&i.Attempt,
&i.ActorID,
&i.ActorKind,
&i.PrincipalID,
&i.Detail,
&i.Data,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const tokensByDay = `-- name: TokensByDay :many
WITH event_totals AS (
SELECT task_id, to_char(at AT TIME ZONE 'UTC', 'YYYY-MM-DD') AS day,
SUM(CASE WHEN jsonb_typeof(data::jsonb -> 'tokens') = 'number'
THEN (data::jsonb ->> 'tokens')::bigint ELSE 0 END) AS tokens,
SUM(CASE WHEN jsonb_typeof(data::jsonb -> 'tokens') = 'number' THEN 1 ELSE 0 END) AS valid_tokens
FROM events WHERE kind = 'agent_finish'
GROUP BY task_id, day
), usage AS (
SELECT day, tokens FROM event_totals WHERE valid_tokens > 0
UNION ALL
SELECT to_char(t.updated_at AT TIME ZONE 'UTC', 'YYYY-MM-DD'), t.tokens_used
FROM tasks t
WHERE t.tokens_used != 0 AND NOT EXISTS (
SELECT 1 FROM event_totals e
WHERE e.task_id = t.id AND e.valid_tokens > 0
)
)
SELECT day, SUM(tokens)::bigint AS tokens
FROM usage GROUP BY day ORDER BY day DESC LIMIT $1
`
type TokensByDayRow struct {
Day string
Tokens int64
}
func (q *Queries) TokensByDay(ctx context.Context, limit int32) ([]TokensByDayRow, error) {
rows, err := q.db.Query(ctx, tokensByDay, limit)
if err != nil {
return nil, err
}
defer rows.Close()
var items []TokensByDayRow
for rows.Next() {
var i TokensByDayRow
if err := rows.Scan(&i.Day, &i.Tokens); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const workflowStats = `-- name: WorkflowStats :many
SELECT workflow,
COUNT(*)::int AS runs,
COUNT(*) FILTER (WHERE status = 'merged')::int AS merged,
COUNT(*) FILTER (WHERE status = 'pr_open')::int AS pr_open,
COUNT(*) FILTER (WHERE status = 'parked')::int AS parked,
CAST(AVG(tokens_used) AS bigint) AS avg_tokens,
AVG(iterations)::float8 AS avg_steps,
SUM(tokens_used)::bigint AS total_tokens
FROM tasks
WHERE workflow <> ''
GROUP BY workflow
ORDER BY COUNT(*) DESC
`
type WorkflowStatsRow struct {
Workflow string
Runs int32
Merged int32
PrOpen int32
Parked int32
AvgTokens int64
AvgSteps float64
TotalTokens int64
}
func (q *Queries) WorkflowStats(ctx context.Context) ([]WorkflowStatsRow, error) {
rows, err := q.db.Query(ctx, workflowStats)
if err != nil {
return nil, err
}
defer rows.Close()
var items []WorkflowStatsRow
for rows.Next() {
var i WorkflowStatsRow
if err := rows.Scan(
&i.Workflow,
&i.Runs,
&i.Merged,
&i.PrOpen,
&i.Parked,
&i.AvgTokens,
&i.AvgSteps,
&i.TotalTokens,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}