Memoh/internal/db/sqlc/session_events.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: session_events.sql

package sqlc

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const countSessionEvents = `-- name: CountSessionEvents :one
SELECT COUNT(*) FROM bot_session_events
WHERE session_id = $1
`

func (q *Queries) CountSessionEvents(ctx context.Context, sessionID pgtype.UUID) (int64, error) {
	row := q.db.QueryRow(ctx, countSessionEvents, sessionID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createSessionEvent = `-- name: CreateSessionEvent :one
INSERT INTO bot_session_events (
  bot_id,
  session_id,
  event_kind,
  event_data,
  external_message_id,
  sender_channel_identity_id,
  received_at_ms
) VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT DO NOTHING
RETURNING id
`

type CreateSessionEventParams struct {
	BotID                   pgtype.UUID `json:"bot_id"`
	SessionID               pgtype.UUID `json:"session_id"`
	EventKind               string      `json:"event_kind"`
	EventData               []byte      `json:"event_data"`
	ExternalMessageID       pgtype.Text `json:"external_message_id"`
	SenderChannelIdentityID pgtype.UUID `json:"sender_channel_identity_id"`
	ReceivedAtMs            int64       `json:"received_at_ms"`
}

func (q *Queries) CreateSessionEvent(ctx context.Context, arg CreateSessionEventParams) (pgtype.UUID, error) {
	row := q.db.QueryRow(ctx, createSessionEvent,
		arg.BotID,
		arg.SessionID,
		arg.EventKind,
		arg.EventData,
		arg.ExternalMessageID,
		arg.SenderChannelIdentityID,
		arg.ReceivedAtMs,
	)
	var id pgtype.UUID
	err := row.Scan(&id)
	return id, err
}

const listSessionEventsBySession = `-- name: ListSessionEventsBySession :many
SELECT id, bot_id, session_id, event_kind, event_data, external_message_id, sender_channel_identity_id, received_at_ms, created_at FROM bot_session_events
WHERE session_id = $1
ORDER BY received_at_ms ASC
`

func (q *Queries) ListSessionEventsBySession(ctx context.Context, sessionID pgtype.UUID) ([]BotSessionEvent, error) {
	rows, err := q.db.Query(ctx, listSessionEventsBySession, sessionID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []BotSessionEvent
	for rows.Next() {
		var i BotSessionEvent
		if err := rows.Scan(
			&i.ID,
			&i.BotID,
			&i.SessionID,
			&i.EventKind,
			&i.EventData,
			&i.ExternalMessageID,
			&i.SenderChannelIdentityID,
			&i.ReceivedAtMs,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listSessionEventsBySessionAfter = `-- name: ListSessionEventsBySessionAfter :many
SELECT id, bot_id, session_id, event_kind, event_data, external_message_id, sender_channel_identity_id, received_at_ms, created_at FROM bot_session_events
WHERE session_id = $1 AND received_at_ms >= $2
ORDER BY received_at_ms ASC
`

type ListSessionEventsBySessionAfterParams struct {
	SessionID    pgtype.UUID `json:"session_id"`
	ReceivedAtMs int64       `json:"received_at_ms"`
}

func (q *Queries) ListSessionEventsBySessionAfter(ctx context.Context, arg ListSessionEventsBySessionAfterParams) ([]BotSessionEvent, error) {
	rows, err := q.db.Query(ctx, listSessionEventsBySessionAfter, arg.SessionID, arg.ReceivedAtMs)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []BotSessionEvent
	for rows.Next() {
		var i BotSessionEvent
		if err := rows.Scan(
			&i.ID,
			&i.BotID,
			&i.SessionID,
			&i.EventKind,
			&i.EventData,
			&i.ExternalMessageID,
			&i.SenderChannelIdentityID,
			&i.ReceivedAtMs,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}