382 lines
9.4 KiB
Go
382 lines
9.4 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: artists.sql
|
|
|
|
package dbq
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const countArtists = `-- name: CountArtists :one
|
|
SELECT COUNT(*) FROM artists
|
|
`
|
|
|
|
func (q *Queries) CountArtists(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countArtists)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countArtistsMatching = `-- name: CountArtistsMatching :one
|
|
SELECT COUNT(*) FROM artists WHERE name ILIKE '%' || $1::text || '%'
|
|
`
|
|
|
|
func (q *Queries) CountArtistsMatching(ctx context.Context, dollar_1 string) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countArtistsMatching, dollar_1)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const deleteArtistIfEmpty = `-- name: DeleteArtistIfEmpty :one
|
|
DELETE FROM artists a
|
|
WHERE a.id = $1
|
|
AND NOT EXISTS (SELECT 1 FROM albums al WHERE al.artist_id = a.id)
|
|
AND NOT EXISTS (SELECT 1 FROM tracks t WHERE t.artist_id = a.id)
|
|
RETURNING a.id
|
|
`
|
|
|
|
// M7 #372: deletes the artist row only when it has no remaining albums
|
|
// AND no remaining tracks (defensive — tracks can in principle exist
|
|
// without an album, though the scanner doesn't write that shape today).
|
|
func (q *Queries) DeleteArtistIfEmpty(ctx context.Context, id pgtype.UUID) (pgtype.UUID, error) {
|
|
row := q.db.QueryRow(ctx, deleteArtistIfEmpty, id)
|
|
var id_2 pgtype.UUID
|
|
err := row.Scan(&id_2)
|
|
return id_2, err
|
|
}
|
|
|
|
const getArtistByID = `-- name: GetArtistByID :one
|
|
SELECT id, name, sort_name, mbid, created_at, updated_at FROM artists WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) GetArtistByID(ctx context.Context, id pgtype.UUID) (Artist, error) {
|
|
row := q.db.QueryRow(ctx, getArtistByID, id)
|
|
var i Artist
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.SortName,
|
|
&i.Mbid,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getArtistByName = `-- name: GetArtistByName :one
|
|
SELECT id, name, sort_name, mbid, created_at, updated_at FROM artists WHERE name = $1 LIMIT 1
|
|
`
|
|
|
|
func (q *Queries) GetArtistByName(ctx context.Context, name string) (Artist, error) {
|
|
row := q.db.QueryRow(ctx, getArtistByName, name)
|
|
var i Artist
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.SortName,
|
|
&i.Mbid,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getArtistsByIDs = `-- name: GetArtistsByIDs :many
|
|
SELECT id, name, sort_name, mbid, created_at, updated_at FROM artists WHERE id = ANY($1::uuid[])
|
|
`
|
|
|
|
// Batched lookup used by M5c suggestion attribution to resolve top-3
|
|
// contributing seed UUIDs back to artist names in one round-trip.
|
|
func (q *Queries) GetArtistsByIDs(ctx context.Context, dollar_1 []pgtype.UUID) ([]Artist, error) {
|
|
rows, err := q.db.Query(ctx, getArtistsByIDs, dollar_1)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Artist
|
|
for rows.Next() {
|
|
var i Artist
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.SortName,
|
|
&i.Mbid,
|
|
&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 listArtists = `-- name: ListArtists :many
|
|
SELECT id, name, sort_name, mbid, created_at, updated_at FROM artists ORDER BY sort_name
|
|
`
|
|
|
|
func (q *Queries) ListArtists(ctx context.Context) ([]Artist, error) {
|
|
rows, err := q.db.Query(ctx, listArtists)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Artist
|
|
for rows.Next() {
|
|
var i Artist
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.SortName,
|
|
&i.Mbid,
|
|
&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 listArtistsAlpha = `-- name: ListArtistsAlpha :many
|
|
SELECT id, name, sort_name, mbid, created_at, updated_at FROM artists ORDER BY sort_name, name, id LIMIT $1 OFFSET $2
|
|
`
|
|
|
|
type ListArtistsAlphaParams struct {
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
func (q *Queries) ListArtistsAlpha(ctx context.Context, arg ListArtistsAlphaParams) ([]Artist, error) {
|
|
rows, err := q.db.Query(ctx, listArtistsAlpha, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Artist
|
|
for rows.Next() {
|
|
var i Artist
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.SortName,
|
|
&i.Mbid,
|
|
&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 listArtistsAlphaWithCovers = `-- name: ListArtistsAlphaWithCovers :many
|
|
SELECT artists.id, artists.name, artists.sort_name, artists.mbid, artists.created_at, artists.updated_at,
|
|
cov.id AS cover_album_id,
|
|
cnt.album_count::bigint AS album_count
|
|
FROM artists
|
|
LEFT JOIN LATERAL (
|
|
SELECT id FROM albums
|
|
WHERE artist_id = artists.id AND cover_art_path IS NOT NULL
|
|
ORDER BY created_at DESC LIMIT 1
|
|
) cov ON true
|
|
LEFT JOIN LATERAL (
|
|
SELECT count(*) AS album_count
|
|
FROM albums WHERE artist_id = artists.id
|
|
) cnt ON true
|
|
ORDER BY artists.sort_name, artists.name, artists.id
|
|
LIMIT $1 OFFSET $2
|
|
`
|
|
|
|
type ListArtistsAlphaWithCoversParams struct {
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
type ListArtistsAlphaWithCoversRow struct {
|
|
Artist Artist
|
|
CoverAlbumID pgtype.UUID
|
|
AlbumCount int64
|
|
}
|
|
|
|
// M6a: alpha-sorted artist list with derived cover_album_id (most-recent
|
|
// album whose cover_art_path is set). Replaces ListArtistsAlpha for the
|
|
// /api/artists?sort=alpha branch — the new column is appended, so the
|
|
// alpha branch is purely additive on the wire. album_count is computed
|
|
// in the same query to drop the old N+1 in handleListArtists.
|
|
func (q *Queries) ListArtistsAlphaWithCovers(ctx context.Context, arg ListArtistsAlphaWithCoversParams) ([]ListArtistsAlphaWithCoversRow, error) {
|
|
rows, err := q.db.Query(ctx, listArtistsAlphaWithCovers, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ListArtistsAlphaWithCoversRow
|
|
for rows.Next() {
|
|
var i ListArtistsAlphaWithCoversRow
|
|
if err := rows.Scan(
|
|
&i.Artist.ID,
|
|
&i.Artist.Name,
|
|
&i.Artist.SortName,
|
|
&i.Artist.Mbid,
|
|
&i.Artist.CreatedAt,
|
|
&i.Artist.UpdatedAt,
|
|
&i.CoverAlbumID,
|
|
&i.AlbumCount,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listArtistsNewest = `-- name: ListArtistsNewest :many
|
|
SELECT id, name, sort_name, mbid, created_at, updated_at FROM artists ORDER BY created_at DESC, id DESC LIMIT $1 OFFSET $2
|
|
`
|
|
|
|
type ListArtistsNewestParams struct {
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
// Secondary id tiebreaker keeps pagination stable when created_at ties.
|
|
func (q *Queries) ListArtistsNewest(ctx context.Context, arg ListArtistsNewestParams) ([]Artist, error) {
|
|
rows, err := q.db.Query(ctx, listArtistsNewest, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Artist
|
|
for rows.Next() {
|
|
var i Artist
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.SortName,
|
|
&i.Mbid,
|
|
&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 searchArtists = `-- name: SearchArtists :many
|
|
SELECT id, name, sort_name, mbid, created_at, updated_at FROM artists
|
|
WHERE name ILIKE '%' || $1 || '%'
|
|
ORDER BY sort_name
|
|
LIMIT $2 OFFSET $3
|
|
`
|
|
|
|
type SearchArtistsParams struct {
|
|
Column1 *string
|
|
Limit int32
|
|
Offset int32
|
|
}
|
|
|
|
func (q *Queries) SearchArtists(ctx context.Context, arg SearchArtistsParams) ([]Artist, error) {
|
|
rows, err := q.db.Query(ctx, searchArtists, arg.Column1, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Artist
|
|
for rows.Next() {
|
|
var i Artist
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.SortName,
|
|
&i.Mbid,
|
|
&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 setArtistMbidIfNull = `-- name: SetArtistMbidIfNull :exec
|
|
UPDATE artists
|
|
SET mbid = $2,
|
|
updated_at = now()
|
|
WHERE id = $1 AND mbid IS NULL
|
|
`
|
|
|
|
type SetArtistMbidIfNullParams struct {
|
|
ID pgtype.UUID
|
|
Mbid *string
|
|
}
|
|
|
|
// M7 #379: heal MBID on existing artist rows during rescan. Idempotent —
|
|
// only updates when the existing mbid is NULL, so concurrent scans don't
|
|
// overwrite an existing value with a stale one.
|
|
func (q *Queries) SetArtistMbidIfNull(ctx context.Context, arg SetArtistMbidIfNullParams) error {
|
|
_, err := q.db.Exec(ctx, setArtistMbidIfNull, arg.ID, arg.Mbid)
|
|
return err
|
|
}
|
|
|
|
const upsertArtist = `-- name: UpsertArtist :one
|
|
INSERT INTO artists (name, sort_name, mbid)
|
|
VALUES ($1, $2, $3)
|
|
ON CONFLICT (mbid) WHERE mbid IS NOT NULL
|
|
DO UPDATE SET
|
|
name = EXCLUDED.name,
|
|
sort_name = EXCLUDED.sort_name,
|
|
updated_at = now()
|
|
RETURNING id, name, sort_name, mbid, created_at, updated_at
|
|
`
|
|
|
|
type UpsertArtistParams struct {
|
|
Name string
|
|
SortName string
|
|
Mbid *string
|
|
}
|
|
|
|
// Insert or update by mbid when present; otherwise by (name, sort_name).
|
|
// Callers pass the canonical sort_name; scanner is responsible for derivation.
|
|
func (q *Queries) UpsertArtist(ctx context.Context, arg UpsertArtistParams) (Artist, error) {
|
|
row := q.db.QueryRow(ctx, upsertArtist, arg.Name, arg.SortName, arg.Mbid)
|
|
var i Artist
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.SortName,
|
|
&i.Mbid,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|