Yimaru-BackEnd/gen/db/programs.sql.go

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

package dbgen

import (
	"context"

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

const CreateProgram = `-- name: CreateProgram :one
INSERT INTO programs (name, description, category, thumbnail, sort_order)
SELECT
    $1,
    $2,
    $3,
    $4,
    COALESCE($5::int, COALESCE((
        SELECT
            max(p.sort_order)
        FROM programs AS p), 0) + 1)
RETURNING
    id, name, description, thumbnail, created_at, updated_at, sort_order, category
`

type CreateProgramParams struct {
	Name        string      `json:"name"`
	Description pgtype.Text `json:"description"`
	Category    string      `json:"category"`
	Thumbnail   pgtype.Text `json:"thumbnail"`
	SortOrder   pgtype.Int4 `json:"sort_order"`
}

func (q *Queries) CreateProgram(ctx context.Context, arg CreateProgramParams) (Program, error) {
	row := q.db.QueryRow(ctx, CreateProgram,
		arg.Name,
		arg.Description,
		arg.Category,
		arg.Thumbnail,
		arg.SortOrder,
	)
	var i Program
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Thumbnail,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.SortOrder,
		&i.Category,
	)
	return i, err
}

const DeleteProgram = `-- name: DeleteProgram :exec
DELETE FROM programs
WHERE id = $1
`

func (q *Queries) DeleteProgram(ctx context.Context, id int64) error {
	_, err := q.db.Exec(ctx, DeleteProgram, id)
	return err
}

const GetProgramByID = `-- name: GetProgramByID :one
SELECT id, name, description, thumbnail, created_at, updated_at, sort_order, category
FROM programs
WHERE id = $1
`

func (q *Queries) GetProgramByID(ctx context.Context, id int64) (Program, error) {
	row := q.db.QueryRow(ctx, GetProgramByID, id)
	var i Program
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Thumbnail,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.SortOrder,
		&i.Category,
	)
	return i, err
}

const ListAllProgramIDs = `-- name: ListAllProgramIDs :many
SELECT
    p.id
FROM
    programs AS p
ORDER BY
    p.id
`

func (q *Queries) ListAllProgramIDs(ctx context.Context) ([]int64, error) {
	rows, err := q.db.Query(ctx, ListAllProgramIDs)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var id int64
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const ListPrograms = `-- name: ListPrograms :many
SELECT
    COUNT(*) OVER () AS total_count,
    p.id,
    p.name,
    p.description,
    p.category,
    p.thumbnail,
    p.sort_order,
    p.created_at,
    p.updated_at
FROM programs p
ORDER BY p.sort_order ASC, p.id ASC
LIMIT $1 OFFSET $2
`

type ListProgramsParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

type ListProgramsRow struct {
	TotalCount  int64              `json:"total_count"`
	ID          int64              `json:"id"`
	Name        string             `json:"name"`
	Description pgtype.Text        `json:"description"`
	Category    string             `json:"category"`
	Thumbnail   pgtype.Text        `json:"thumbnail"`
	SortOrder   int32              `json:"sort_order"`
	CreatedAt   pgtype.Timestamptz `json:"created_at"`
	UpdatedAt   pgtype.Timestamptz `json:"updated_at"`
}

func (q *Queries) ListPrograms(ctx context.Context, arg ListProgramsParams) ([]ListProgramsRow, error) {
	rows, err := q.db.Query(ctx, ListPrograms, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListProgramsRow
	for rows.Next() {
		var i ListProgramsRow
		if err := rows.Scan(
			&i.TotalCount,
			&i.ID,
			&i.Name,
			&i.Description,
			&i.Category,
			&i.Thumbnail,
			&i.SortOrder,
			&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 UpdateProgram = `-- name: UpdateProgram :one
UPDATE programs
SET
    name = COALESCE($1::varchar, name),
    description = COALESCE($2::text, description),
    category = COALESCE($3::varchar, category),
    thumbnail = COALESCE($4::text, thumbnail),
    sort_order = coalesce($5::int, sort_order),
    updated_at = CURRENT_TIMESTAMP
WHERE
    id = $6
RETURNING
    id, name, description, thumbnail, created_at, updated_at, sort_order, category
`

type UpdateProgramParams struct {
	Name        pgtype.Text `json:"name"`
	Description pgtype.Text `json:"description"`
	Category    pgtype.Text `json:"category"`
	Thumbnail   pgtype.Text `json:"thumbnail"`
	SortOrder   pgtype.Int4 `json:"sort_order"`
	ID          int64       `json:"id"`
}

func (q *Queries) UpdateProgram(ctx context.Context, arg UpdateProgramParams) (Program, error) {
	row := q.db.QueryRow(ctx, UpdateProgram,
		arg.Name,
		arg.Description,
		arg.Category,
		arg.Thumbnail,
		arg.SortOrder,
		arg.ID,
	)
	var i Program
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Thumbnail,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.SortOrder,
		&i.Category,
	)
	return i, err
}