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, publish_status, access_tier)
SELECT
    $1,
    $2,
    $3,
    $4,
    COALESCE($5::int, COALESCE((
        SELECT
            max(p.sort_order)
        FROM programs AS p), 0) + 1),
    $6,
    $7
RETURNING
    id, name, description, thumbnail, created_at, updated_at, sort_order, category, publish_status, access_tier
`

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"`
	PublishStatus string      `json:"publish_status"`
	AccessTier    string      `json:"access_tier"`
}

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,
		arg.PublishStatus,
		arg.AccessTier,
	)
	var i Program
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Thumbnail,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.SortOrder,
		&i.Category,
		&i.PublishStatus,
		&i.AccessTier,
	)
	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, publish_status, access_tier
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,
		&i.PublishStatus,
		&i.AccessTier,
	)
	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.publish_status,
    p.access_tier,
    p.created_at,
    p.updated_at
FROM programs p
WHERE (
    $3::boolean = FALSE
    OR p.publish_status = 'PUBLISHED'::TEXT
)
AND (
    $4::text = ''
    OR p.category = $4::text
)
ORDER BY p.sort_order ASC, p.id ASC
LIMIT $1 OFFSET $2
`

type ListProgramsParams struct {
	Limit         int32  `json:"limit"`
	Offset        int32  `json:"offset"`
	PublishedOnly bool   `json:"published_only"`
	Category      string `json:"category"`
}

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"`
	PublishStatus string             `json:"publish_status"`
	AccessTier    string             `json:"access_tier"`
	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,
		arg.PublishedOnly,
		arg.Category,
	)
	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.PublishStatus,
			&i.AccessTier,
			&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),
    publish_status = COALESCE($6::varchar, publish_status),
    access_tier = COALESCE($7::varchar, access_tier),
    updated_at = CURRENT_TIMESTAMP
WHERE
    id = $8
RETURNING
    id, name, description, thumbnail, created_at, updated_at, sort_order, category, publish_status, access_tier
`

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"`
	PublishStatus pgtype.Text `json:"publish_status"`
	AccessTier    pgtype.Text `json:"access_tier"`
	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.PublishStatus,
		arg.AccessTier,
		arg.ID,
	)
	var i Program
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Thumbnail,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.SortOrder,
		&i.Category,
		&i.PublishStatus,
		&i.AccessTier,
	)
	return i, err
}