// Code generated by sqlc. DO NOT EDIT. // versions: // sqlc v1.27.0 // source: msgchains.sql package database import ( "context" "database/sql" "encoding/json" "time" "github.com/lib/pq" ) const createMsgChain = `-- name: CreateMsgChain :one INSERT INTO msgchains ( type, model, model_provider, usage_in, usage_out, usage_cache_in, usage_cache_out, usage_cost_in, usage_cost_out, duration_seconds, chain, flow_id, task_id, subtask_id ) VALUES ( $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14 ) RETURNING id, type, model, model_provider, usage_in, usage_out, chain, flow_id, task_id, subtask_id, created_at, updated_at, usage_cache_in, usage_cache_out, usage_cost_in, usage_cost_out, duration_seconds ` type CreateMsgChainParams struct { Type MsgchainType `json:"type"` Model string `json:"model"` ModelProvider string `json:"model_provider"` UsageIn int64 `json:"usage_in"` UsageOut int64 `json:"usage_out"` UsageCacheIn int64 `json:"usage_cache_in"` UsageCacheOut int64 `json:"usage_cache_out"` UsageCostIn float64 `json:"usage_cost_in"` UsageCostOut float64 `json:"usage_cost_out"` DurationSeconds float64 `json:"duration_seconds"` Chain json.RawMessage `json:"chain"` FlowID int64 `json:"flow_id"` TaskID sql.NullInt64 `json:"task_id"` SubtaskID sql.NullInt64 `json:"subtask_id"` } func (q *Queries) CreateMsgChain(ctx context.Context, arg CreateMsgChainParams) (Msgchain, error) { row := q.db.QueryRowContext(ctx, createMsgChain, arg.Type, arg.Model, arg.ModelProvider, arg.UsageIn, arg.UsageOut, arg.UsageCacheIn, arg.UsageCacheOut, arg.UsageCostIn, arg.UsageCostOut, arg.DurationSeconds, arg.Chain, arg.FlowID, arg.TaskID, arg.SubtaskID, ) var i Msgchain err := row.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ) return i, err } const getAllFlowsUsageStats = `-- name: GetAllFlowsUsageStats :many SELECT mc.flow_id AS flow_id, COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc INNER JOIN flows f ON f.id = mc.flow_id WHERE f.deleted_at IS NULL GROUP BY mc.flow_id ORDER BY mc.flow_id ` type GetAllFlowsUsageStatsRow struct { FlowID int64 `json:"flow_id"` TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetAllFlowsUsageStats(ctx context.Context) ([]GetAllFlowsUsageStatsRow, error) { rows, err := q.db.QueryContext(ctx, getAllFlowsUsageStats) if err != nil { return nil, err } defer rows.Close() var items []GetAllFlowsUsageStatsRow for rows.Next() { var i GetAllFlowsUsageStatsRow if err := rows.Scan( &i.FlowID, &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getFlowMsgChains = `-- name: GetFlowMsgChains :many SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc LEFT JOIN subtasks s ON mc.subtask_id = s.id LEFT JOIN tasks t ON s.task_id = t.id WHERE mc.flow_id = $1 OR t.flow_id = $1 ORDER BY mc.created_at DESC ` func (q *Queries) GetFlowMsgChains(ctx context.Context, flowID int64) ([]Msgchain, error) { rows, err := q.db.QueryContext(ctx, getFlowMsgChains, flowID) if err != nil { return nil, err } defer rows.Close() var items []Msgchain for rows.Next() { var i Msgchain if err := rows.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getFlowTaskTypeLastMsgChain = `-- name: GetFlowTaskTypeLastMsgChain :one SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc WHERE mc.flow_id = $1 AND (mc.task_id = $2 OR $2 IS NULL) AND mc.type = $3 ORDER BY mc.created_at DESC LIMIT 1 ` type GetFlowTaskTypeLastMsgChainParams struct { FlowID int64 `json:"flow_id"` TaskID sql.NullInt64 `json:"task_id"` Type MsgchainType `json:"type"` } func (q *Queries) GetFlowTaskTypeLastMsgChain(ctx context.Context, arg GetFlowTaskTypeLastMsgChainParams) (Msgchain, error) { row := q.db.QueryRowContext(ctx, getFlowTaskTypeLastMsgChain, arg.FlowID, arg.TaskID, arg.Type) var i Msgchain err := row.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ) return i, err } const getFlowTypeMsgChains = `-- name: GetFlowTypeMsgChains :many SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc LEFT JOIN subtasks s ON mc.subtask_id = s.id LEFT JOIN tasks t ON s.task_id = t.id WHERE (mc.flow_id = $1 OR t.flow_id = $1) AND mc.type = $2 ORDER BY mc.created_at DESC ` type GetFlowTypeMsgChainsParams struct { FlowID int64 `json:"flow_id"` Type MsgchainType `json:"type"` } func (q *Queries) GetFlowTypeMsgChains(ctx context.Context, arg GetFlowTypeMsgChainsParams) ([]Msgchain, error) { rows, err := q.db.QueryContext(ctx, getFlowTypeMsgChains, arg.FlowID, arg.Type) if err != nil { return nil, err } defer rows.Close() var items []Msgchain for rows.Next() { var i Msgchain if err := rows.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getFlowUsageStats = `-- name: GetFlowUsageStats :one SELECT COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc INNER JOIN flows f ON f.id = mc.flow_id WHERE mc.flow_id = $1 AND f.deleted_at IS NULL ` type GetFlowUsageStatsRow struct { TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetFlowUsageStats(ctx context.Context, flowID int64) (GetFlowUsageStatsRow, error) { row := q.db.QueryRowContext(ctx, getFlowUsageStats, flowID) var i GetFlowUsageStatsRow err := row.Scan( &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ) return i, err } const getMsgChain = `-- name: GetMsgChain :one SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc WHERE mc.id = $1 ` func (q *Queries) GetMsgChain(ctx context.Context, id int64) (Msgchain, error) { row := q.db.QueryRowContext(ctx, getMsgChain, id) var i Msgchain err := row.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ) return i, err } const getSubtaskMsgChains = `-- name: GetSubtaskMsgChains :many SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc WHERE mc.subtask_id = $1 ORDER BY mc.created_at DESC ` func (q *Queries) GetSubtaskMsgChains(ctx context.Context, subtaskID sql.NullInt64) ([]Msgchain, error) { rows, err := q.db.QueryContext(ctx, getSubtaskMsgChains, subtaskID) if err != nil { return nil, err } defer rows.Close() var items []Msgchain for rows.Next() { var i Msgchain if err := rows.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getSubtaskPrimaryMsgChains = `-- name: GetSubtaskPrimaryMsgChains :many SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc WHERE mc.subtask_id = $1 AND mc.type = 'primary_agent' ORDER BY mc.created_at DESC ` func (q *Queries) GetSubtaskPrimaryMsgChains(ctx context.Context, subtaskID sql.NullInt64) ([]Msgchain, error) { rows, err := q.db.QueryContext(ctx, getSubtaskPrimaryMsgChains, subtaskID) if err != nil { return nil, err } defer rows.Close() var items []Msgchain for rows.Next() { var i Msgchain if err := rows.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getSubtaskTypeMsgChains = `-- name: GetSubtaskTypeMsgChains :many SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc WHERE mc.subtask_id = $1 AND mc.type = $2 ORDER BY mc.created_at DESC ` type GetSubtaskTypeMsgChainsParams struct { SubtaskID sql.NullInt64 `json:"subtask_id"` Type MsgchainType `json:"type"` } func (q *Queries) GetSubtaskTypeMsgChains(ctx context.Context, arg GetSubtaskTypeMsgChainsParams) ([]Msgchain, error) { rows, err := q.db.QueryContext(ctx, getSubtaskTypeMsgChains, arg.SubtaskID, arg.Type) if err != nil { return nil, err } defer rows.Close() var items []Msgchain for rows.Next() { var i Msgchain if err := rows.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getSubtaskUsageStats = `-- name: GetSubtaskUsageStats :one SELECT COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc LEFT JOIN subtasks s ON mc.subtask_id = s.id LEFT JOIN tasks t ON s.task_id = t.id INNER JOIN flows f ON (mc.flow_id = f.id OR t.flow_id = f.id) WHERE mc.subtask_id = $1 AND f.deleted_at IS NULL ` type GetSubtaskUsageStatsRow struct { TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetSubtaskUsageStats(ctx context.Context, subtaskID sql.NullInt64) (GetSubtaskUsageStatsRow, error) { row := q.db.QueryRowContext(ctx, getSubtaskUsageStats, subtaskID) var i GetSubtaskUsageStatsRow err := row.Scan( &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ) return i, err } const getTaskMsgChains = `-- name: GetTaskMsgChains :many SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc LEFT JOIN subtasks s ON mc.subtask_id = s.id WHERE mc.task_id = $1 OR s.task_id = $1 ORDER BY mc.created_at DESC ` func (q *Queries) GetTaskMsgChains(ctx context.Context, taskID sql.NullInt64) ([]Msgchain, error) { rows, err := q.db.QueryContext(ctx, getTaskMsgChains, taskID) if err != nil { return nil, err } defer rows.Close() var items []Msgchain for rows.Next() { var i Msgchain if err := rows.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getTaskPrimaryMsgChainIDs = `-- name: GetTaskPrimaryMsgChainIDs :many SELECT DISTINCT mc.id, mc.subtask_id FROM msgchains mc LEFT JOIN subtasks s ON mc.subtask_id = s.id WHERE (mc.task_id = $1 OR s.task_id = $1) AND mc.type = 'primary_agent' ` type GetTaskPrimaryMsgChainIDsRow struct { ID int64 `json:"id"` SubtaskID sql.NullInt64 `json:"subtask_id"` } func (q *Queries) GetTaskPrimaryMsgChainIDs(ctx context.Context, taskID sql.NullInt64) ([]GetTaskPrimaryMsgChainIDsRow, error) { rows, err := q.db.QueryContext(ctx, getTaskPrimaryMsgChainIDs, taskID) if err != nil { return nil, err } defer rows.Close() var items []GetTaskPrimaryMsgChainIDsRow for rows.Next() { var i GetTaskPrimaryMsgChainIDsRow if err := rows.Scan(&i.ID, &i.SubtaskID); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getTaskPrimaryMsgChains = `-- name: GetTaskPrimaryMsgChains :many SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc LEFT JOIN subtasks s ON mc.subtask_id = s.id WHERE (mc.task_id = $1 OR s.task_id = $1) AND mc.type = 'primary_agent' ORDER BY mc.created_at DESC ` func (q *Queries) GetTaskPrimaryMsgChains(ctx context.Context, taskID sql.NullInt64) ([]Msgchain, error) { rows, err := q.db.QueryContext(ctx, getTaskPrimaryMsgChains, taskID) if err != nil { return nil, err } defer rows.Close() var items []Msgchain for rows.Next() { var i Msgchain if err := rows.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getTaskTypeMsgChains = `-- name: GetTaskTypeMsgChains :many SELECT mc.id, mc.type, mc.model, mc.model_provider, mc.usage_in, mc.usage_out, mc.chain, mc.flow_id, mc.task_id, mc.subtask_id, mc.created_at, mc.updated_at, mc.usage_cache_in, mc.usage_cache_out, mc.usage_cost_in, mc.usage_cost_out, mc.duration_seconds FROM msgchains mc LEFT JOIN subtasks s ON mc.subtask_id = s.id WHERE (mc.task_id = $1 OR s.task_id = $1) AND mc.type = $2 ORDER BY mc.created_at DESC ` type GetTaskTypeMsgChainsParams struct { TaskID sql.NullInt64 `json:"task_id"` Type MsgchainType `json:"type"` } func (q *Queries) GetTaskTypeMsgChains(ctx context.Context, arg GetTaskTypeMsgChainsParams) ([]Msgchain, error) { rows, err := q.db.QueryContext(ctx, getTaskTypeMsgChains, arg.TaskID, arg.Type) if err != nil { return nil, err } defer rows.Close() var items []Msgchain for rows.Next() { var i Msgchain if err := rows.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getTaskUsageStats = `-- name: GetTaskUsageStats :one SELECT COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc LEFT JOIN subtasks s ON mc.subtask_id = s.id LEFT JOIN tasks t ON mc.task_id = t.id OR s.task_id = t.id INNER JOIN flows f ON (mc.flow_id = f.id OR t.flow_id = f.id) WHERE (mc.task_id = $1 OR s.task_id = $1) AND f.deleted_at IS NULL ` type GetTaskUsageStatsRow struct { TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetTaskUsageStats(ctx context.Context, taskID sql.NullInt64) (GetTaskUsageStatsRow, error) { row := q.db.QueryRowContext(ctx, getTaskUsageStats, taskID) var i GetTaskUsageStatsRow err := row.Scan( &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ) return i, err } const getUsageStatsByDay = `-- name: GetUsageStatsByDay :many WITH bounds AS ( SELECT ((NOW() AT TIME ZONE $1::text)::date - $2::int) AS first_day, (NOW() AT TIME ZONE $1::text)::date AS last_day ), days AS ( SELECT generate_series(b.first_day, b.last_day, INTERVAL '1 day')::date AS day FROM bounds b ), agg AS ( SELECT (mc.created_at AT TIME ZONE $1::text)::date AS day, SUM(mc.usage_in)::bigint AS total_usage_in, SUM(mc.usage_out)::bigint AS total_usage_out, SUM(mc.usage_cache_in)::bigint AS total_usage_cache_in, SUM(mc.usage_cache_out)::bigint AS total_usage_cache_out, SUM(mc.usage_cost_in)::double precision AS total_usage_cost_in, SUM(mc.usage_cost_out)::double precision AS total_usage_cost_out FROM msgchains mc INNER JOIN flows f ON f.id = mc.flow_id WHERE f.deleted_at IS NULL AND f.user_id = $3 -- The coarse bounds keep the index; the exact test repeats the grouping -- expression, because an ambiguous local midnight resolves to the later -- instant and would drop the earlier hour of that day. AND mc.created_at >= (((SELECT first_day FROM bounds) - 1)::timestamp AT TIME ZONE $1::text) AND mc.created_at < (((SELECT last_day FROM bounds) + 2)::timestamp AT TIME ZONE $1::text) AND (mc.created_at AT TIME ZONE $1::text)::date BETWEEN (SELECT first_day FROM bounds) AND (SELECT last_day FROM bounds) GROUP BY 1 ) SELECT (d.day::timestamp AT TIME ZONE $1::text) AS date, COALESCE(a.total_usage_in, 0)::bigint AS total_usage_in, COALESCE(a.total_usage_out, 0)::bigint AS total_usage_out, COALESCE(a.total_usage_cache_in, 0)::bigint AS total_usage_cache_in, COALESCE(a.total_usage_cache_out, 0)::bigint AS total_usage_cache_out, COALESCE(a.total_usage_cost_in, 0.0)::double precision AS total_usage_cost_in, COALESCE(a.total_usage_cost_out, 0.0)::double precision AS total_usage_cost_out FROM days d LEFT JOIN agg a ON a.day = d.day ORDER BY date DESC ` type GetUsageStatsByDayParams struct { Tz string `json:"tz"` Days int32 `json:"days"` UserID int64 `json:"user_id"` } type GetUsageStatsByDayRow struct { Date time.Time `json:"date"` TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } // One dense row per calendar day in the caller's timezone, zeros included. func (q *Queries) GetUsageStatsByDay(ctx context.Context, arg GetUsageStatsByDayParams) ([]GetUsageStatsByDayRow, error) { rows, err := q.db.QueryContext(ctx, getUsageStatsByDay, arg.Tz, arg.Days, arg.UserID) if err != nil { return nil, err } defer rows.Close() var items []GetUsageStatsByDayRow for rows.Next() { var i GetUsageStatsByDayRow if err := rows.Scan( &i.Date, &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getUsageStatsByModel = `-- name: GetUsageStatsByModel :many SELECT mc.model, mc.model_provider, COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc INNER JOIN flows f ON f.id = mc.flow_id WHERE f.deleted_at IS NULL AND f.user_id = $1 GROUP BY mc.model, mc.model_provider ORDER BY mc.model, mc.model_provider ` type GetUsageStatsByModelRow struct { Model string `json:"model"` ModelProvider string `json:"model_provider"` TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetUsageStatsByModel(ctx context.Context, userID int64) ([]GetUsageStatsByModelRow, error) { rows, err := q.db.QueryContext(ctx, getUsageStatsByModel, userID) if err != nil { return nil, err } defer rows.Close() var items []GetUsageStatsByModelRow for rows.Next() { var i GetUsageStatsByModelRow if err := rows.Scan( &i.Model, &i.ModelProvider, &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getUsageStatsByModelAgentsForFlow = `-- name: GetUsageStatsByModelAgentsForFlow :many SELECT mc.model, mc.model_provider, array_agg(DISTINCT mc.type::text)::text[] AS agent_types, COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc INNER JOIN flows f ON f.id = mc.flow_id WHERE mc.flow_id = $1 AND f.deleted_at IS NULL GROUP BY mc.model, mc.model_provider ORDER BY mc.model, mc.model_provider ` type GetUsageStatsByModelAgentsForFlowRow struct { Model string `json:"model"` ModelProvider string `json:"model_provider"` AgentTypes []string `json:"agent_types"` TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetUsageStatsByModelAgentsForFlow(ctx context.Context, flowID int64) ([]GetUsageStatsByModelAgentsForFlowRow, error) { rows, err := q.db.QueryContext(ctx, getUsageStatsByModelAgentsForFlow, flowID) if err != nil { return nil, err } defer rows.Close() var items []GetUsageStatsByModelAgentsForFlowRow for rows.Next() { var i GetUsageStatsByModelAgentsForFlowRow if err := rows.Scan( &i.Model, &i.ModelProvider, pq.Array(&i.AgentTypes), &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getUsageStatsByProvider = `-- name: GetUsageStatsByProvider :many SELECT mc.model_provider, COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc INNER JOIN flows f ON f.id = mc.flow_id WHERE f.deleted_at IS NULL AND f.user_id = $1 GROUP BY mc.model_provider ORDER BY mc.model_provider ` type GetUsageStatsByProviderRow struct { ModelProvider string `json:"model_provider"` TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetUsageStatsByProvider(ctx context.Context, userID int64) ([]GetUsageStatsByProviderRow, error) { rows, err := q.db.QueryContext(ctx, getUsageStatsByProvider, userID) if err != nil { return nil, err } defer rows.Close() var items []GetUsageStatsByProviderRow for rows.Next() { var i GetUsageStatsByProviderRow if err := rows.Scan( &i.ModelProvider, &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getUsageStatsByType = `-- name: GetUsageStatsByType :many SELECT mc.type, COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc INNER JOIN flows f ON f.id = mc.flow_id WHERE f.deleted_at IS NULL AND f.user_id = $1 GROUP BY mc.type ORDER BY mc.type ` type GetUsageStatsByTypeRow struct { Type MsgchainType `json:"type"` TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetUsageStatsByType(ctx context.Context, userID int64) ([]GetUsageStatsByTypeRow, error) { rows, err := q.db.QueryContext(ctx, getUsageStatsByType, userID) if err != nil { return nil, err } defer rows.Close() var items []GetUsageStatsByTypeRow for rows.Next() { var i GetUsageStatsByTypeRow if err := rows.Scan( &i.Type, &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getUsageStatsByTypeForFlow = `-- name: GetUsageStatsByTypeForFlow :many SELECT mc.type, COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc INNER JOIN flows f ON f.id = mc.flow_id WHERE mc.flow_id = $1 AND f.deleted_at IS NULL GROUP BY mc.type ORDER BY mc.type ` type GetUsageStatsByTypeForFlowRow struct { Type MsgchainType `json:"type"` TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetUsageStatsByTypeForFlow(ctx context.Context, flowID int64) ([]GetUsageStatsByTypeForFlowRow, error) { rows, err := q.db.QueryContext(ctx, getUsageStatsByTypeForFlow, flowID) if err != nil { return nil, err } defer rows.Close() var items []GetUsageStatsByTypeForFlowRow for rows.Next() { var i GetUsageStatsByTypeForFlowRow if err := rows.Scan( &i.Type, &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ); err != nil { return nil, err } items = append(items, i) } if err := rows.Close(); err != nil { return nil, err } if err := rows.Err(); err != nil { return nil, err } return items, nil } const getUserTotalUsageStats = `-- name: GetUserTotalUsageStats :one SELECT COALESCE(SUM(mc.usage_in), 0)::bigint AS total_usage_in, COALESCE(SUM(mc.usage_out), 0)::bigint AS total_usage_out, COALESCE(SUM(mc.usage_cache_in), 0)::bigint AS total_usage_cache_in, COALESCE(SUM(mc.usage_cache_out), 0)::bigint AS total_usage_cache_out, COALESCE(SUM(mc.usage_cost_in), 0.0)::double precision AS total_usage_cost_in, COALESCE(SUM(mc.usage_cost_out), 0.0)::double precision AS total_usage_cost_out FROM msgchains mc INNER JOIN flows f ON f.id = mc.flow_id WHERE f.deleted_at IS NULL AND f.user_id = $1 ` type GetUserTotalUsageStatsRow struct { TotalUsageIn int64 `json:"total_usage_in"` TotalUsageOut int64 `json:"total_usage_out"` TotalUsageCacheIn int64 `json:"total_usage_cache_in"` TotalUsageCacheOut int64 `json:"total_usage_cache_out"` TotalUsageCostIn float64 `json:"total_usage_cost_in"` TotalUsageCostOut float64 `json:"total_usage_cost_out"` } func (q *Queries) GetUserTotalUsageStats(ctx context.Context, userID int64) (GetUserTotalUsageStatsRow, error) { row := q.db.QueryRowContext(ctx, getUserTotalUsageStats, userID) var i GetUserTotalUsageStatsRow err := row.Scan( &i.TotalUsageIn, &i.TotalUsageOut, &i.TotalUsageCacheIn, &i.TotalUsageCacheOut, &i.TotalUsageCostIn, &i.TotalUsageCostOut, ) return i, err } const updateMsgChain = `-- name: UpdateMsgChain :one UPDATE msgchains SET chain = $1, duration_seconds = duration_seconds + $2, model = $3, model_provider = $4 WHERE id = $5 RETURNING id, type, model, model_provider, usage_in, usage_out, chain, flow_id, task_id, subtask_id, created_at, updated_at, usage_cache_in, usage_cache_out, usage_cost_in, usage_cost_out, duration_seconds ` type UpdateMsgChainParams struct { Chain json.RawMessage `json:"chain"` DurationSeconds float64 `json:"duration_seconds"` Model string `json:"model"` ModelProvider string `json:"model_provider"` ID int64 `json:"id"` } func (q *Queries) UpdateMsgChain(ctx context.Context, arg UpdateMsgChainParams) (Msgchain, error) { row := q.db.QueryRowContext(ctx, updateMsgChain, arg.Chain, arg.DurationSeconds, arg.Model, arg.ModelProvider, arg.ID, ) var i Msgchain err := row.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ) return i, err } const updateMsgChainUsage = `-- name: UpdateMsgChainUsage :one UPDATE msgchains SET usage_in = usage_in + $1, usage_out = usage_out + $2, usage_cache_in = usage_cache_in + $3, usage_cache_out = usage_cache_out + $4, usage_cost_in = usage_cost_in + $5, usage_cost_out = usage_cost_out + $6, duration_seconds = duration_seconds + $7 WHERE id = $8 RETURNING id, type, model, model_provider, usage_in, usage_out, chain, flow_id, task_id, subtask_id, created_at, updated_at, usage_cache_in, usage_cache_out, usage_cost_in, usage_cost_out, duration_seconds ` type UpdateMsgChainUsageParams struct { UsageIn int64 `json:"usage_in"` UsageOut int64 `json:"usage_out"` UsageCacheIn int64 `json:"usage_cache_in"` UsageCacheOut int64 `json:"usage_cache_out"` UsageCostIn float64 `json:"usage_cost_in"` UsageCostOut float64 `json:"usage_cost_out"` DurationSeconds float64 `json:"duration_seconds"` ID int64 `json:"id"` } func (q *Queries) UpdateMsgChainUsage(ctx context.Context, arg UpdateMsgChainUsageParams) (Msgchain, error) { row := q.db.QueryRowContext(ctx, updateMsgChainUsage, arg.UsageIn, arg.UsageOut, arg.UsageCacheIn, arg.UsageCacheOut, arg.UsageCostIn, arg.UsageCostOut, arg.DurationSeconds, arg.ID, ) var i Msgchain err := row.Scan( &i.ID, &i.Type, &i.Model, &i.ModelProvider, &i.UsageIn, &i.UsageOut, &i.Chain, &i.FlowID, &i.TaskID, &i.SubtaskID, &i.CreatedAt, &i.UpdatedAt, &i.UsageCacheIn, &i.UsageCacheOut, &i.UsageCostIn, &i.UsageCostOut, &i.DurationSeconds, ) return i, err }