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

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

package sqlc

import (
	"context"

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

const deleteSettingsByBotID = `-- name: DeleteSettingsByBotID :exec
DELETE FROM bot_settings
WHERE bot_id = $1
`

func (q *Queries) DeleteSettingsByBotID(ctx context.Context, botID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteSettingsByBotID, botID)
	return err
}

const getBotModelConfigByBotID = `-- name: GetBotModelConfigByBotID :one
SELECT
  bot_model_configs.bot_id,
  chat_models.model_id AS chat_model_id,
  memory_models.model_id AS memory_model_id,
  embedding_models.model_id AS embedding_model_id
FROM bot_model_configs
LEFT JOIN models AS chat_models ON chat_models.id = bot_model_configs.chat_model_id
LEFT JOIN models AS memory_models ON memory_models.id = bot_model_configs.memory_model_id
LEFT JOIN models AS embedding_models ON embedding_models.id = bot_model_configs.embedding_model_id
WHERE bot_model_configs.bot_id = $1
`

type GetBotModelConfigByBotIDRow struct {
	BotID            pgtype.UUID `json:"bot_id"`
	ChatModelID      pgtype.Text `json:"chat_model_id"`
	MemoryModelID    pgtype.Text `json:"memory_model_id"`
	EmbeddingModelID pgtype.Text `json:"embedding_model_id"`
}

func (q *Queries) GetBotModelConfigByBotID(ctx context.Context, botID pgtype.UUID) (GetBotModelConfigByBotIDRow, error) {
	row := q.db.QueryRow(ctx, getBotModelConfigByBotID, botID)
	var i GetBotModelConfigByBotIDRow
	err := row.Scan(
		&i.BotID,
		&i.ChatModelID,
		&i.MemoryModelID,
		&i.EmbeddingModelID,
	)
	return i, err
}

const getSettingsByBotID = `-- name: GetSettingsByBotID :one
SELECT bot_id, max_context_load_time, language, allow_guest
FROM bot_settings
WHERE bot_id = $1
`

func (q *Queries) GetSettingsByBotID(ctx context.Context, botID pgtype.UUID) (BotSetting, error) {
	row := q.db.QueryRow(ctx, getSettingsByBotID, botID)
	var i BotSetting
	err := row.Scan(
		&i.BotID,
		&i.MaxContextLoadTime,
		&i.Language,
		&i.AllowGuest,
	)
	return i, err
}

const getSettingsByUserID = `-- name: GetSettingsByUserID :one
SELECT user_id, chat_model_id, memory_model_id, embedding_model_id, max_context_load_time, language
FROM user_settings
WHERE user_id = $1
`

func (q *Queries) GetSettingsByUserID(ctx context.Context, userID pgtype.UUID) (UserSetting, error) {
	row := q.db.QueryRow(ctx, getSettingsByUserID, userID)
	var i UserSetting
	err := row.Scan(
		&i.UserID,
		&i.ChatModelID,
		&i.MemoryModelID,
		&i.EmbeddingModelID,
		&i.MaxContextLoadTime,
		&i.Language,
	)
	return i, err
}

const upsertBotModelConfig = `-- name: UpsertBotModelConfig :one
INSERT INTO bot_model_configs (bot_id, chat_model_id, memory_model_id, embedding_model_id)
VALUES ($1, $2, $3, $4)
ON CONFLICT (bot_id) DO UPDATE SET
  chat_model_id = COALESCE(EXCLUDED.chat_model_id, bot_model_configs.chat_model_id),
  memory_model_id = COALESCE(EXCLUDED.memory_model_id, bot_model_configs.memory_model_id),
  embedding_model_id = COALESCE(EXCLUDED.embedding_model_id, bot_model_configs.embedding_model_id)
RETURNING bot_id, chat_model_id, memory_model_id, embedding_model_id
`

type UpsertBotModelConfigParams struct {
	BotID            pgtype.UUID `json:"bot_id"`
	ChatModelID      pgtype.UUID `json:"chat_model_id"`
	MemoryModelID    pgtype.UUID `json:"memory_model_id"`
	EmbeddingModelID pgtype.UUID `json:"embedding_model_id"`
}

type UpsertBotModelConfigRow struct {
	BotID            pgtype.UUID `json:"bot_id"`
	ChatModelID      pgtype.UUID `json:"chat_model_id"`
	MemoryModelID    pgtype.UUID `json:"memory_model_id"`
	EmbeddingModelID pgtype.UUID `json:"embedding_model_id"`
}

func (q *Queries) UpsertBotModelConfig(ctx context.Context, arg UpsertBotModelConfigParams) (UpsertBotModelConfigRow, error) {
	row := q.db.QueryRow(ctx, upsertBotModelConfig,
		arg.BotID,
		arg.ChatModelID,
		arg.MemoryModelID,
		arg.EmbeddingModelID,
	)
	var i UpsertBotModelConfigRow
	err := row.Scan(
		&i.BotID,
		&i.ChatModelID,
		&i.MemoryModelID,
		&i.EmbeddingModelID,
	)
	return i, err
}

const upsertBotSettings = `-- name: UpsertBotSettings :one
INSERT INTO bot_settings (bot_id, max_context_load_time, language, allow_guest)
VALUES ($1, $2, $3, $4)
ON CONFLICT (bot_id) DO UPDATE SET
  max_context_load_time = EXCLUDED.max_context_load_time,
  language = EXCLUDED.language,
  allow_guest = EXCLUDED.allow_guest
RETURNING bot_id, max_context_load_time, language, allow_guest
`

type UpsertBotSettingsParams struct {
	BotID              pgtype.UUID `json:"bot_id"`
	MaxContextLoadTime int32       `json:"max_context_load_time"`
	Language           string      `json:"language"`
	AllowGuest         bool        `json:"allow_guest"`
}

func (q *Queries) UpsertBotSettings(ctx context.Context, arg UpsertBotSettingsParams) (BotSetting, error) {
	row := q.db.QueryRow(ctx, upsertBotSettings,
		arg.BotID,
		arg.MaxContextLoadTime,
		arg.Language,
		arg.AllowGuest,
	)
	var i BotSetting
	err := row.Scan(
		&i.BotID,
		&i.MaxContextLoadTime,
		&i.Language,
		&i.AllowGuest,
	)
	return i, err
}

const upsertUserSettings = `-- name: UpsertUserSettings :one
INSERT INTO user_settings (user_id, chat_model_id, memory_model_id, embedding_model_id, max_context_load_time, language)
VALUES ($1, $2, $3, $4, $5, $6)
ON CONFLICT (user_id) DO UPDATE SET
  chat_model_id = EXCLUDED.chat_model_id,
  memory_model_id = EXCLUDED.memory_model_id,
  embedding_model_id = EXCLUDED.embedding_model_id,
  max_context_load_time = EXCLUDED.max_context_load_time,
  language = EXCLUDED.language
RETURNING user_id, chat_model_id, memory_model_id, embedding_model_id, max_context_load_time, language
`

type UpsertUserSettingsParams struct {
	UserID             pgtype.UUID `json:"user_id"`
	ChatModelID        pgtype.Text `json:"chat_model_id"`
	MemoryModelID      pgtype.Text `json:"memory_model_id"`
	EmbeddingModelID   pgtype.Text `json:"embedding_model_id"`
	MaxContextLoadTime int32       `json:"max_context_load_time"`
	Language           string      `json:"language"`
}

func (q *Queries) UpsertUserSettings(ctx context.Context, arg UpsertUserSettingsParams) (UserSetting, error) {
	row := q.db.QueryRow(ctx, upsertUserSettings,
		arg.UserID,
		arg.ChatModelID,
		arg.MemoryModelID,
		arg.EmbeddingModelID,
		arg.MaxContextLoadTime,
		arg.Language,
	)
	var i UserSetting
	err := row.Scan(
		&i.UserID,
		&i.ChatModelID,
		&i.MemoryModelID,
		&i.EmbeddingModelID,
		&i.MaxContextLoadTime,
		&i.Language,
	)
	return i, err
}