// Code generated by sqlc. DO NOT EDIT. // versions: // sqlc v1.31.1 // source: events.sql package postgresdb import ( "context" "time" "github.com/jackc/pgx/v5/pgtype" ) const insertEvent = `-- name: InsertEvent :one WITH append_lock AS ( SELECT pg_advisory_xact_lock(hashtextextended('archie.events.insert', 0)) ) INSERT INTO events (at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data, org_id, workspace_id) SELECT $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, COALESCE(t.org_id, $14::text), COALESCE(t.workspace_id, 'default') FROM append_lock LEFT JOIN tasks t ON t.id = $3 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 OrgID 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. // InsertEvent takes the event-append lock before the row draws its id, and // holds it until the enclosing transaction commits, so ids become visible in // the order they were drawn. The lock is inside the statement so a standalone // insert and one inside a longer transaction both take it. 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, arg.OrgID, ) 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, org_id, workspace_id FROM events WHERE (at > $1 OR (at = $1 AND id > $2)) AND ($3::text IS NULL OR org_id = $3) ORDER BY at, id LIMIT $4 ` type ListEventsAfterParams struct { At time.Time ID int64 ScopeOrg pgtype.Text PageLimit int32 } func (q *Queries) ListEventsAfter(ctx context.Context, arg ListEventsAfterParams) ([]Event, error) { rows, err := q.db.Query(ctx, listEventsAfter, arg.At, arg.ID, arg.ScopeOrg, arg.PageLimit, ) 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, &i.OrgID, &i.WorkspaceID, ); 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, org_id, workspace_id FROM events WHERE ($1::text IS NULL OR org_id = $1) ORDER BY at, id LIMIT $2 ` type ListEventsFromBeginningParams struct { ScopeOrg pgtype.Text PageLimit int32 } func (q *Queries) ListEventsFromBeginning(ctx context.Context, arg ListEventsFromBeginningParams) ([]Event, error) { rows, err := q.db.Query(ctx, listEventsFromBeginning, arg.ScopeOrg, arg.PageLimit) 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, &i.OrgID, &i.WorkspaceID, ); 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, COALESCE(CAST(AVG((data::jsonb ->> 'duration_ms')::numeric) AS bigint), 0)::bigint AS avg_ms, COUNT(*) FILTER (WHERE (data::jsonb ->> 'error') IS NOT NULL)::int AS errors FROM events WHERE kind = 'stage_finish' AND ($1::text IS NULL OR org_id = $1) AND task_id NOT IN (SELECT id FROM tasks WHERE source = 'test') 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, scopeOrg pgtype.Text) ([]StageStatsRow, error) { rows, err := q.db.Query(ctx, stageStats, scopeOrg) 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, org_id, workspace_id FROM events WHERE task_id = $1 AND ($2::text IS NULL OR org_id = $2) ORDER BY id ` type TaskEventsByIDParams struct { TaskID int64 ScopeOrg pgtype.Text } func (q *Queries) TaskEventsByID(ctx context.Context, arg TaskEventsByIDParams) ([]Event, error) { rows, err := q.db.Query(ctx, taskEventsByID, arg.TaskID, arg.ScopeOrg) 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, &i.OrgID, &i.WorkspaceID, ); 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' AND ($2::text IS NULL OR org_id = $2) 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 ($2::text IS NULL OR t.org_id = $2) 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 TokensByDayParams struct { Days int32 ScopeOrg pgtype.Text } type TokensByDayRow struct { Day string Tokens int64 } func (q *Queries) TokensByDay(ctx context.Context, arg TokensByDayParams) ([]TokensByDayRow, error) { rows, err := q.db.Query(ctx, tokensByDay, arg.Days, arg.ScopeOrg) 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 = 'completed')::int AS completed, 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 <> '' AND source <> 'test' AND ($1::text IS NULL OR org_id = $1) GROUP BY workflow ORDER BY COUNT(*) DESC ` type WorkflowStatsRow struct { Workflow string Runs int32 Merged int32 Completed int32 PrOpen int32 Parked int32 AvgTokens int64 AvgSteps float64 TotalTokens int64 } func (q *Queries) WorkflowStats(ctx context.Context, scopeOrg pgtype.Text) ([]WorkflowStatsRow, error) { rows, err := q.db.Query(ctx, workflowStats, scopeOrg) 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.Completed, &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 }