Files

904 lines
23 KiB
Go

// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: gateway.sql
package postgresdb
import (
"context"
)
const claimSession = `-- name: ClaimSession :exec
INSERT INTO sessions (session_id, org_id) VALUES ($1, $2)
ON CONFLICT (session_id) DO NOTHING
`
type ClaimSessionParams struct {
SessionID string
OrgID string
}
// A write to a session no row names yet makes the writing org its owner.
func (q *Queries) ClaimSession(ctx context.Context, arg ClaimSessionParams) error {
_, err := q.db.Exec(ctx, claimSession, arg.SessionID, arg.OrgID)
return err
}
const countMessages = `-- name: CountMessages :one
SELECT COUNT(*) FROM messages WHERE session_id = $1
`
func (q *Queries) CountMessages(ctx context.Context, sessionID string) (int64, error) {
row := q.db.QueryRow(ctx, countMessages, sessionID)
var count int64
err := row.Scan(&count)
return count, err
}
const deleteMessagesByID = `-- name: DeleteMessagesByID :exec
DELETE FROM messages WHERE session_id = $1 AND message_id = ANY($2::text[])
`
type DeleteMessagesByIDParams struct {
SessionID string
Ids []string
}
func (q *Queries) DeleteMessagesByID(ctx context.Context, arg DeleteMessagesByIDParams) error {
_, err := q.db.Exec(ctx, deleteMessagesByID, arg.SessionID, arg.Ids)
return err
}
const deleteRecentMessages = `-- name: DeleteRecentMessages :execrows
DELETE FROM messages WHERE id IN (
SELECT m.id FROM messages m WHERE m.session_id = $1 ORDER BY m.ts DESC LIMIT $2
)
`
type DeleteRecentMessagesParams struct {
SessionID string
Limit int32
}
func (q *Queries) DeleteRecentMessages(ctx context.Context, arg DeleteRecentMessagesParams) (int64, error) {
result, err := q.db.Exec(ctx, deleteRecentMessages, arg.SessionID, arg.Limit)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const deleteSession = `-- name: DeleteSession :exec
DELETE FROM sessions WHERE session_id = $1
`
func (q *Queries) DeleteSession(ctx context.Context, sessionID string) error {
_, err := q.db.Exec(ctx, deleteSession, sessionID)
return err
}
const deleteSessionMessages = `-- name: DeleteSessionMessages :exec
DELETE FROM messages WHERE session_id = $1
`
func (q *Queries) DeleteSessionMessages(ctx context.Context, sessionID string) error {
_, err := q.db.Exec(ctx, deleteSessionMessages, sessionID)
return err
}
const deleteSessionTurns = `-- name: DeleteSessionTurns :exec
DELETE FROM turns WHERE session_id = $1
`
func (q *Queries) DeleteSessionTurns(ctx context.Context, sessionID string) error {
_, err := q.db.Exec(ctx, deleteSessionTurns, sessionID)
return err
}
const finalizeTurn = `-- name: FinalizeTurn :execrows
UPDATE turns SET status = $2, error = $3, updated_at = $4
WHERE turn_id = $1 AND attempt = $5 AND owner_id = $6
`
type FinalizeTurnParams struct {
TurnID string
Status string
Error string
UpdatedAt int64
Attempt int64
OwnerID string
}
func (q *Queries) FinalizeTurn(ctx context.Context, arg FinalizeTurnParams) (int64, error) {
result, err := q.db.Exec(ctx, finalizeTurn,
arg.TurnID,
arg.Status,
arg.Error,
arg.UpdatedAt,
arg.Attempt,
arg.OwnerID,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const insertMessageAt = `-- name: InsertMessageAt :exec
INSERT INTO messages (message_id, session_id, source_id, sender, sender_id, role, text, media, ts)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
ON CONFLICT (session_id, message_id) DO NOTHING
`
type InsertMessageAtParams struct {
MessageID string
SessionID string
SourceID string
Sender string
SenderID string
Role string
Text string
Media []byte
Ts int64
}
// Rewriting history places records deliberately, so no clamp applies.
func (q *Queries) InsertMessageAt(ctx context.Context, arg InsertMessageAtParams) error {
_, err := q.db.Exec(ctx, insertMessageAt,
arg.MessageID,
arg.SessionID,
arg.SourceID,
arg.Sender,
arg.SenderID,
arg.Role,
arg.Text,
arg.Media,
arg.Ts,
)
return err
}
const insertMessageClamped = `-- name: InsertMessageClamped :exec
INSERT INTO messages (message_id, session_id, source_id, sender, sender_id, role, text, media, ts)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, (
SELECT CASE
WHEN MAX(m.ts) IS NOT NULL AND MAX(m.ts) >= $9 THEN MAX(m.ts) + 1
ELSE $9
END
FROM messages m WHERE m.session_id = $2
))
ON CONFLICT (session_id, message_id) DO NOTHING
`
type InsertMessageClampedParams struct {
MessageID string
SessionID string
SourceID string
Sender string
SenderID string
Role string
Text string
Media []byte
Ts int64
}
// The append path's strictly-increasing timestamp. The clamp is computed in
// SQL, not in Go: the CASE assigns MAX(ts)+1 when the caller's timestamp is
// not ahead of the session's newest, else the caller's timestamp. A Go-side
// read-then-write would race two concurrent appends to the same session.
func (q *Queries) InsertMessageClamped(ctx context.Context, arg InsertMessageClampedParams) error {
_, err := q.db.Exec(ctx, insertMessageClamped,
arg.MessageID,
arg.SessionID,
arg.SourceID,
arg.Sender,
arg.SenderID,
arg.Role,
arg.Text,
arg.Media,
arg.Ts,
)
return err
}
const insertTurn = `-- name: InsertTurn :execrows
INSERT INTO turns (turn_id, session_id, source_id, status, attempt, owner_id,
input_message_id, assistant_message_id, partial_text,
response_text, tool_calls, error, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
ON CONFLICT (turn_id) DO NOTHING
`
type InsertTurnParams struct {
TurnID string
SessionID string
SourceID string
Status string
Attempt int64
OwnerID string
InputMessageID string
AssistantMessageID string
PartialText string
ResponseText string
ToolCalls string
Error string
CreatedAt int64
UpdatedAt int64
}
// ── Turns ───────────────────────────────────────────────────────────────────
func (q *Queries) InsertTurn(ctx context.Context, arg InsertTurnParams) (int64, error) {
result, err := q.db.Exec(ctx, insertTurn,
arg.TurnID,
arg.SessionID,
arg.SourceID,
arg.Status,
arg.Attempt,
arg.OwnerID,
arg.InputMessageID,
arg.AssistantMessageID,
arg.PartialText,
arg.ResponseText,
arg.ToolCalls,
arg.Error,
arg.CreatedAt,
arg.UpdatedAt,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const listRecoverableTurns = `-- name: ListRecoverableTurns :many
SELECT turn_id, session_id, source_id, status, attempt, owner_id,
input_message_id, assistant_message_id, partial_text,
response_text, tool_calls, error, created_at, updated_at
FROM turns WHERE status IN ('accepted', 'running', 'partial') ORDER BY updated_at ASC
`
func (q *Queries) ListRecoverableTurns(ctx context.Context) ([]Turn, error) {
rows, err := q.db.Query(ctx, listRecoverableTurns)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Turn
for rows.Next() {
var i Turn
if err := rows.Scan(
&i.TurnID,
&i.SessionID,
&i.SourceID,
&i.Status,
&i.Attempt,
&i.OwnerID,
&i.InputMessageID,
&i.AssistantMessageID,
&i.PartialText,
&i.ResponseText,
&i.ToolCalls,
&i.Error,
&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 listSessions = `-- name: ListSessions :many
SELECT session_id, platform, bot_user, channel_id, thread_id,
title, parent_session_id, branch_name, created_at, last_active_at, org_id
FROM sessions
WHERE org_id = $1
ORDER BY GREATEST(last_active_at, created_at) DESC
`
func (q *Queries) ListSessions(ctx context.Context, orgID string) ([]Session, error) {
rows, err := q.db.Query(ctx, listSessions, orgID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Session
for rows.Next() {
var i Session
if err := rows.Scan(
&i.SessionID,
&i.Platform,
&i.BotUser,
&i.ChannelID,
&i.ThreadID,
&i.Title,
&i.ParentSessionID,
&i.BranchName,
&i.CreatedAt,
&i.LastActiveAt,
&i.OrgID,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const lockSessionMessages = `-- name: LockSessionMessages :exec
SELECT pg_advisory_xact_lock(hashtextextended('messages:' || $1::text, 0))
`
// ── Messages ────────────────────────────────────────────────────────────────
// Serialises message appends per session so the monotonic clamp's MAX(ts)
// read cannot race a concurrent append of the same session. Transaction-scoped:
// released at commit/rollback, which is exactly the lifetime of the append.
func (q *Queries) LockSessionMessages(ctx context.Context, dollar_1 string) error {
_, err := q.db.Exec(ctx, lockSessionMessages, dollar_1)
return err
}
const messageID = `-- name: MessageID :one
SELECT message_id FROM messages WHERE session_id = $1 AND message_id = $2
`
type MessageIDParams struct {
SessionID string
MessageID string
}
func (q *Queries) MessageID(ctx context.Context, arg MessageIDParams) (string, error) {
row := q.db.QueryRow(ctx, messageID, arg.SessionID, arg.MessageID)
var message_id string
err := row.Scan(&message_id)
return message_id, err
}
const nextReplyAfterTs = `-- name: NextReplyAfterTs :one
SELECT sender, text FROM messages
WHERE session_id = $1 AND ts > $2 ORDER BY ts ASC LIMIT 1
`
type NextReplyAfterTsParams struct {
SessionID string
Ts int64
}
type NextReplyAfterTsRow struct {
Sender string
Text string
}
func (q *Queries) NextReplyAfterTs(ctx context.Context, arg NextReplyAfterTsParams) (NextReplyAfterTsRow, error) {
row := q.db.QueryRow(ctx, nextReplyAfterTs, arg.SessionID, arg.Ts)
var i NextReplyAfterTsRow
err := row.Scan(&i.Sender, &i.Text)
return i, err
}
const recentMessages = `-- name: RecentMessages :many
SELECT m.message_id, m.source_id, m.sender, m.sender_id, m.role, m.text, m.ts, m.media::text AS media,
COALESCE(s.channel_id, '') AS channel_id, COALESCE(s.thread_id, '') AS thread_id
FROM (
SELECT msg.message_id, msg.source_id, msg.sender, msg.sender_id, msg.role, msg.text, msg.ts, msg.media::text AS media, msg.session_id
FROM messages msg WHERE msg.session_id = $1 ORDER BY msg.ts DESC LIMIT $2
) m
LEFT JOIN sessions s ON s.session_id = m.session_id
ORDER BY m.ts ASC
`
type RecentMessagesParams struct {
SessionID string
Limit int32
}
type RecentMessagesRow struct {
MessageID string
SourceID string
Sender string
SenderID string
Role string
Text string
Ts int64
Media string
ChannelID string
ThreadID string
}
func (q *Queries) RecentMessages(ctx context.Context, arg RecentMessagesParams) ([]RecentMessagesRow, error) {
rows, err := q.db.Query(ctx, recentMessages, arg.SessionID, arg.Limit)
if err != nil {
return nil, err
}
defer rows.Close()
var items []RecentMessagesRow
for rows.Next() {
var i RecentMessagesRow
if err := rows.Scan(
&i.MessageID,
&i.SourceID,
&i.Sender,
&i.SenderID,
&i.Role,
&i.Text,
&i.Ts,
&i.Media,
&i.ChannelID,
&i.ThreadID,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const recentTurns = `-- name: RecentTurns :many
SELECT turn_id, session_id, source_id, status, attempt, owner_id,
input_message_id, assistant_message_id, partial_text,
response_text, tool_calls, error, created_at, updated_at
FROM turns WHERE session_id = $1 ORDER BY created_at DESC LIMIT $2
`
type RecentTurnsParams struct {
SessionID string
Limit int32
}
func (q *Queries) RecentTurns(ctx context.Context, arg RecentTurnsParams) ([]Turn, error) {
rows, err := q.db.Query(ctx, recentTurns, arg.SessionID, arg.Limit)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Turn
for rows.Next() {
var i Turn
if err := rows.Scan(
&i.TurnID,
&i.SessionID,
&i.SourceID,
&i.Status,
&i.Attempt,
&i.OwnerID,
&i.InputMessageID,
&i.AssistantMessageID,
&i.PartialText,
&i.ResponseText,
&i.ToolCalls,
&i.Error,
&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 recoverTurns = `-- name: RecoverTurns :exec
UPDATE turns SET status = 'failed', error = 'recovered after process restart', updated_at = $1
WHERE status IN ('accepted', 'running', 'partial') AND owner_id <> $2
`
type RecoverTurnsParams struct {
UpdatedAt int64
OwnerID string
}
func (q *Queries) RecoverTurns(ctx context.Context, arg RecoverTurnsParams) error {
_, err := q.db.Exec(ctx, recoverTurns, arg.UpdatedAt, arg.OwnerID)
return err
}
const retryTurn = `-- name: RetryTurn :execrows
UPDATE turns SET status = $2, attempt = $3, owner_id = $4, error = $5, updated_at = $6
WHERE turn_id = $1 AND attempt = $7 AND owner_id = $8
`
type RetryTurnParams struct {
TurnID string
Status string
Attempt int64
OwnerID string
Error string
UpdatedAt int64
Attempt_2 int64
OwnerID_2 string
}
func (q *Queries) RetryTurn(ctx context.Context, arg RetryTurnParams) (int64, error) {
result, err := q.db.Exec(ctx, retryTurn,
arg.TurnID,
arg.Status,
arg.Attempt,
arg.OwnerID,
arg.Error,
arg.UpdatedAt,
arg.Attempt_2,
arg.OwnerID_2,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const saveSession = `-- name: SaveSession :execrows
INSERT INTO sessions (session_id, platform, bot_user, channel_id, thread_id,
title, parent_session_id, branch_name, created_at, last_active_at, org_id)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
ON CONFLICT (session_id) DO UPDATE SET
platform = EXCLUDED.platform,
bot_user = EXCLUDED.bot_user,
channel_id = EXCLUDED.channel_id,
thread_id = EXCLUDED.thread_id,
title = EXCLUDED.title,
parent_session_id = EXCLUDED.parent_session_id,
branch_name = EXCLUDED.branch_name,
created_at = EXCLUDED.created_at,
last_active_at = EXCLUDED.last_active_at
WHERE sessions.org_id = EXCLUDED.org_id
AND (
(sessions.platform = '' AND sessions.bot_user = '' AND sessions.channel_id = '' AND sessions.thread_id = '')
OR (sessions.platform = EXCLUDED.platform AND sessions.bot_user = EXCLUDED.bot_user
AND sessions.channel_id = EXCLUDED.channel_id AND sessions.thread_id = EXCLUDED.thread_id)
)
`
type SaveSessionParams struct {
SessionID string
Platform string
BotUser string
ChannelID string
ThreadID string
Title string
ParentSessionID string
BranchName string
CreatedAt int64
LastActiveAt int64
OrgID string
}
// Gateway conversation queries: sessions, messages, turns, full-text search.
// These back internal/gateway's PostgreSQL SessionStore.
// ── Sessions ────────────────────────────────────────────────────────────────
// A saved session keeps its organization and conversation identity. Empty
// placeholder rows may be completed; an existing conversation cannot be claimed
// by overwriting its source with another person's thread.
func (q *Queries) SaveSession(ctx context.Context, arg SaveSessionParams) (int64, error) {
result, err := q.db.Exec(ctx, saveSession,
arg.SessionID,
arg.Platform,
arg.BotUser,
arg.ChannelID,
arg.ThreadID,
arg.Title,
arg.ParentSessionID,
arg.BranchName,
arg.CreatedAt,
arg.LastActiveAt,
arg.OrgID,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const saveTurn = `-- name: SaveTurn :execrows
UPDATE turns SET
session_id = $2, source_id = $3, status = $4, attempt = $5, owner_id = $6,
input_message_id = $7, assistant_message_id = $8, partial_text = $9,
response_text = $10, tool_calls = $11, error = $12, created_at = $13, updated_at = $14
WHERE turn_id = $1 AND attempt = $5 AND owner_id = $6
`
type SaveTurnParams struct {
TurnID string
SessionID string
SourceID string
Status string
Attempt int64
OwnerID string
InputMessageID string
AssistantMessageID string
PartialText string
ResponseText string
ToolCalls string
Error string
CreatedAt int64
UpdatedAt int64
}
func (q *Queries) SaveTurn(ctx context.Context, arg SaveTurnParams) (int64, error) {
result, err := q.db.Exec(ctx, saveTurn,
arg.TurnID,
arg.SessionID,
arg.SourceID,
arg.Status,
arg.Attempt,
arg.OwnerID,
arg.InputMessageID,
arg.AssistantMessageID,
arg.PartialText,
arg.ResponseText,
arg.ToolCalls,
arg.Error,
arg.CreatedAt,
arg.UpdatedAt,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const searchMessagesCount = `-- name: SearchMessagesCount :one
SELECT COUNT(*) FROM messages
WHERE session_id = $1 AND search @@ plainto_tsquery('simple', $2)
`
type SearchMessagesCountParams struct {
SessionID string
PlaintoTsquery string
}
func (q *Queries) SearchMessagesCount(ctx context.Context, arg SearchMessagesCountParams) (int64, error) {
row := q.db.QueryRow(ctx, searchMessagesCount, arg.SessionID, arg.PlaintoTsquery)
var count int64
err := row.Scan(&count)
return count, err
}
const searchMessagesPage = `-- name: SearchMessagesPage :many
SELECT m.message_id, m.source_id, m.sender, m.sender_id, m.role, m.text, m.ts, m.media::text AS media,
COALESCE(s.channel_id, '') AS channel_id, COALESCE(s.thread_id, '') AS thread_id
FROM messages m
LEFT JOIN sessions s ON s.session_id = m.session_id
WHERE m.session_id = $1 AND m.search @@ plainto_tsquery('simple', $2)
ORDER BY ts_rank(m.search, plainto_tsquery('simple', $2)) DESC, m.ts DESC, m.id DESC
LIMIT $3 OFFSET $4
`
type SearchMessagesPageParams struct {
SessionID string
PlaintoTsquery string
Limit int32
Offset int32
}
type SearchMessagesPageRow struct {
MessageID string
SourceID string
Sender string
SenderID string
Role string
Text string
Ts int64
Media string
ChannelID string
ThreadID string
}
func (q *Queries) SearchMessagesPage(ctx context.Context, arg SearchMessagesPageParams) ([]SearchMessagesPageRow, error) {
rows, err := q.db.Query(ctx, searchMessagesPage,
arg.SessionID,
arg.PlaintoTsquery,
arg.Limit,
arg.Offset,
)
if err != nil {
return nil, err
}
defer rows.Close()
var items []SearchMessagesPageRow
for rows.Next() {
var i SearchMessagesPageRow
if err := rows.Scan(
&i.MessageID,
&i.SourceID,
&i.Sender,
&i.SenderID,
&i.Role,
&i.Text,
&i.Ts,
&i.Media,
&i.ChannelID,
&i.ThreadID,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const sessionByID = `-- name: SessionByID :one
SELECT session_id, platform, bot_user, channel_id, thread_id,
title, parent_session_id, branch_name, created_at, last_active_at, org_id
FROM sessions WHERE session_id = $1 AND org_id = $2
`
type SessionByIDParams struct {
SessionID string
OrgID string
}
func (q *Queries) SessionByID(ctx context.Context, arg SessionByIDParams) (Session, error) {
row := q.db.QueryRow(ctx, sessionByID, arg.SessionID, arg.OrgID)
var i Session
err := row.Scan(
&i.SessionID,
&i.Platform,
&i.BotUser,
&i.ChannelID,
&i.ThreadID,
&i.Title,
&i.ParentSessionID,
&i.BranchName,
&i.CreatedAt,
&i.LastActiveAt,
&i.OrgID,
)
return i, err
}
const sessionOrg = `-- name: SessionOrg :one
SELECT org_id FROM sessions WHERE session_id = $1
`
func (q *Queries) SessionOrg(ctx context.Context, sessionID string) (string, error) {
row := q.db.QueryRow(ctx, sessionOrg, sessionID)
var org_id string
err := row.Scan(&org_id)
return org_id, err
}
const sessionsByChannel = `-- name: SessionsByChannel :many
SELECT session_id, platform, bot_user, channel_id, thread_id,
title, parent_session_id, branch_name, created_at, last_active_at, org_id
FROM sessions
WHERE platform = $1 AND channel_id = $2 AND org_id = $3
ORDER BY GREATEST(last_active_at, created_at) DESC
`
type SessionsByChannelParams struct {
Platform string
ChannelID string
OrgID string
}
func (q *Queries) SessionsByChannel(ctx context.Context, arg SessionsByChannelParams) ([]Session, error) {
rows, err := q.db.Query(ctx, sessionsByChannel, arg.Platform, arg.ChannelID, arg.OrgID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Session
for rows.Next() {
var i Session
if err := rows.Scan(
&i.SessionID,
&i.Platform,
&i.BotUser,
&i.ChannelID,
&i.ThreadID,
&i.Title,
&i.ParentSessionID,
&i.BranchName,
&i.CreatedAt,
&i.LastActiveAt,
&i.OrgID,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const sourceMessageTs = `-- name: SourceMessageTs :one
SELECT ts FROM messages
WHERE session_id = $1 AND message_id IN ($2, $3)
ORDER BY CASE WHEN message_id = $3 THEN 0 ELSE 1 END
LIMIT 1
`
type SourceMessageTsParams struct {
SessionID string
MessageID string
MessageID_2 string
}
func (q *Queries) SourceMessageTs(ctx context.Context, arg SourceMessageTsParams) (int64, error) {
row := q.db.QueryRow(ctx, sourceMessageTs, arg.SessionID, arg.MessageID, arg.MessageID_2)
var ts int64
err := row.Scan(&ts)
return ts, err
}
const touchSession = `-- name: TouchSession :exec
UPDATE sessions SET last_active_at = $2 WHERE session_id = $1
`
type TouchSessionParams struct {
SessionID string
LastActiveAt int64
}
func (q *Queries) TouchSession(ctx context.Context, arg TouchSessionParams) error {
_, err := q.db.Exec(ctx, touchSession, arg.SessionID, arg.LastActiveAt)
return err
}
const turnAttemptOwner = `-- name: TurnAttemptOwner :one
SELECT attempt, owner_id FROM turns WHERE turn_id = $1
`
type TurnAttemptOwnerRow struct {
Attempt int64
OwnerID string
}
func (q *Queries) TurnAttemptOwner(ctx context.Context, turnID string) (TurnAttemptOwnerRow, error) {
row := q.db.QueryRow(ctx, turnAttemptOwner, turnID)
var i TurnAttemptOwnerRow
err := row.Scan(&i.Attempt, &i.OwnerID)
return i, err
}
const turnByID = `-- name: TurnByID :one
SELECT turn_id, session_id, source_id, status, attempt, owner_id,
input_message_id, assistant_message_id, partial_text,
response_text, tool_calls, error, created_at, updated_at
FROM turns WHERE turn_id = $1
`
func (q *Queries) TurnByID(ctx context.Context, turnID string) (Turn, error) {
row := q.db.QueryRow(ctx, turnByID, turnID)
var i Turn
err := row.Scan(
&i.TurnID,
&i.SessionID,
&i.SourceID,
&i.Status,
&i.Attempt,
&i.OwnerID,
&i.InputMessageID,
&i.AssistantMessageID,
&i.PartialText,
&i.ResponseText,
&i.ToolCalls,
&i.Error,
&i.CreatedAt,
&i.UpdatedAt,
)
return i, err
}