logan
9e0e4d5bb8
"Play this artist" awaited `GetAlbumTracks` inside a for loop — 13 sequential round trips for a 12-album artist — and every one of the four sites doing that asked for whole track rows to read `FilePath` off them. Five genres cost 6 MB across the IPC. `GetFilePathsByAlbums(ids, libraryID)` and `GetFilePathsByGenres(names, libraryID)` answer once and carry only the paths. Measured at 50 000 tracks: an artist 13 calls / 74.2 kB -> 2 / 19.2 kB, twenty albums 20 / 117.5 kB / 7.8 ms -> 1 / 26.0 kB / 1.7 ms, five genres 5 / 6 014 kB / 213 ms -> 1 / 1 291 kB / 32.6 ms, with the returned path lists identical. They return the paths grouped by album id or genre name rather than flattened, because the caller owns the order — an album list is sorted by name, not by id, and a flattened result would silently reorder a queue — and because the album drag cache stores them per album. A libraryID of 0 means "every library", matching an unset filter.
506 lines
13 KiB
Go
506 lines
13 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.30.0
|
|
// source: genres.sql
|
|
|
|
package sqlcgen
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"strings"
|
|
)
|
|
|
|
const countGenreReferences = `-- name: CountGenreReferences :one
|
|
SELECT COUNT(*) FROM recording_genres WHERE genre_id = ?
|
|
`
|
|
|
|
func (q *Queries) CountGenreReferences(ctx context.Context, genreID int64) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countGenreReferences, genreID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const createRecordingGenre = `-- name: CreateRecordingGenre :exec
|
|
INSERT OR IGNORE INTO recording_genres (recording_id, genre_id)
|
|
VALUES (?, ?)
|
|
`
|
|
|
|
type CreateRecordingGenreParams struct {
|
|
RecordingID int64
|
|
GenreID int64
|
|
}
|
|
|
|
func (q *Queries) CreateRecordingGenre(ctx context.Context, arg CreateRecordingGenreParams) error {
|
|
_, err := q.db.ExecContext(ctx, createRecordingGenre, arg.RecordingID, arg.GenreID)
|
|
return err
|
|
}
|
|
|
|
const deleteAllGenres = `-- name: DeleteAllGenres :exec
|
|
DELETE FROM genres
|
|
`
|
|
|
|
func (q *Queries) DeleteAllGenres(ctx context.Context) error {
|
|
_, err := q.db.ExecContext(ctx, deleteAllGenres)
|
|
return err
|
|
}
|
|
|
|
const deleteAllRecordingGenres = `-- name: DeleteAllRecordingGenres :exec
|
|
DELETE FROM recording_genres
|
|
`
|
|
|
|
func (q *Queries) DeleteAllRecordingGenres(ctx context.Context) error {
|
|
_, err := q.db.ExecContext(ctx, deleteAllRecordingGenres)
|
|
return err
|
|
}
|
|
|
|
const deleteGenre = `-- name: DeleteGenre :exec
|
|
DELETE FROM genres WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteGenre(ctx context.Context, id int64) error {
|
|
_, err := q.db.ExecContext(ctx, deleteGenre, id)
|
|
return err
|
|
}
|
|
|
|
const deleteRecordingGenres = `-- name: DeleteRecordingGenres :exec
|
|
DELETE FROM recording_genres
|
|
WHERE recording_id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteRecordingGenres(ctx context.Context, recordingID int64) error {
|
|
_, err := q.db.ExecContext(ctx, deleteRecordingGenres, recordingID)
|
|
return err
|
|
}
|
|
|
|
const getAllGenresWithCounts = `-- name: GetAllGenresWithCounts :many
|
|
SELECT g.name, COUNT(rg.recording_id) AS track_count
|
|
FROM genres g
|
|
JOIN recording_genres rg ON g.id = rg.genre_id
|
|
GROUP BY g.id, g.name
|
|
ORDER BY g.name
|
|
`
|
|
|
|
type GetAllGenresWithCountsRow struct {
|
|
Name string
|
|
TrackCount int64
|
|
}
|
|
|
|
func (q *Queries) GetAllGenresWithCounts(ctx context.Context) ([]GetAllGenresWithCountsRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getAllGenresWithCounts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetAllGenresWithCountsRow
|
|
for rows.Next() {
|
|
var i GetAllGenresWithCountsRow
|
|
if err := rows.Scan(&i.Name, &i.TrackCount); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getAllGenresWithCountsByLibrary = `-- name: GetAllGenresWithCountsByLibrary :many
|
|
SELECT g.name, COUNT(rg.recording_id) AS track_count
|
|
FROM genres g
|
|
JOIN recording_genres rg ON g.id = rg.genre_id
|
|
JOIN recordings r ON rg.recording_id = r.id
|
|
JOIN audio_files af ON af.recording_id = r.id
|
|
WHERE af.library_id = ?
|
|
GROUP BY g.id, g.name
|
|
ORDER BY g.name
|
|
`
|
|
|
|
type GetAllGenresWithCountsByLibraryRow struct {
|
|
Name string
|
|
TrackCount int64
|
|
}
|
|
|
|
func (q *Queries) GetAllGenresWithCountsByLibrary(ctx context.Context, libraryID int64) ([]GetAllGenresWithCountsByLibraryRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getAllGenresWithCountsByLibrary, libraryID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetAllGenresWithCountsByLibraryRow
|
|
for rows.Next() {
|
|
var i GetAllGenresWithCountsByLibraryRow
|
|
if err := rows.Scan(&i.Name, &i.TrackCount); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getFilePathsByGenres = `-- name: GetFilePathsByGenres :many
|
|
|
|
SELECT g.name AS genre_name, af.file_path
|
|
FROM genres g
|
|
JOIN recording_genres rg ON g.id = rg.genre_id
|
|
JOIN recordings r ON rg.recording_id = r.id
|
|
JOIN audio_files af ON af.recording_id = r.id
|
|
WHERE g.name IN (/*SLICE:genre_names*/?)
|
|
ORDER BY r.name
|
|
`
|
|
|
|
type GetFilePathsByGenresRow struct {
|
|
GenreName string
|
|
FilePath string
|
|
}
|
|
|
|
// Same as GetFilePathsByReleaseGroups, for "play these genres" (perf.m2):
|
|
// one query instead of one per genre, and file paths instead of whole
|
|
// track rows, which was 6 MB over the IPC for five genres.
|
|
func (q *Queries) GetFilePathsByGenres(ctx context.Context, genreNames []string) ([]GetFilePathsByGenresRow, error) {
|
|
query := getFilePathsByGenres
|
|
var queryParams []interface{}
|
|
if len(genreNames) > 0 {
|
|
for _, v := range genreNames {
|
|
queryParams = append(queryParams, v)
|
|
}
|
|
query = strings.Replace(query, "/*SLICE:genre_names*/?", strings.Repeat(",?", len(genreNames))[1:], 1)
|
|
} else {
|
|
query = strings.Replace(query, "/*SLICE:genre_names*/?", "NULL", 1)
|
|
}
|
|
rows, err := q.db.QueryContext(ctx, query, queryParams...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetFilePathsByGenresRow
|
|
for rows.Next() {
|
|
var i GetFilePathsByGenresRow
|
|
if err := rows.Scan(&i.GenreName, &i.FilePath); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getFilePathsByGenresByLibrary = `-- name: GetFilePathsByGenresByLibrary :many
|
|
SELECT g.name AS genre_name, af.file_path
|
|
FROM genres g
|
|
JOIN recording_genres rg ON g.id = rg.genre_id
|
|
JOIN recordings r ON rg.recording_id = r.id
|
|
JOIN audio_files af ON af.recording_id = r.id
|
|
WHERE g.name IN (/*SLICE:genre_names*/?)
|
|
AND af.library_id = ?
|
|
ORDER BY r.name
|
|
`
|
|
|
|
type GetFilePathsByGenresByLibraryParams struct {
|
|
GenreNames []string
|
|
LibraryID int64
|
|
}
|
|
|
|
type GetFilePathsByGenresByLibraryRow struct {
|
|
GenreName string
|
|
FilePath string
|
|
}
|
|
|
|
func (q *Queries) GetFilePathsByGenresByLibrary(ctx context.Context, arg GetFilePathsByGenresByLibraryParams) ([]GetFilePathsByGenresByLibraryRow, error) {
|
|
query := getFilePathsByGenresByLibrary
|
|
var queryParams []interface{}
|
|
if len(arg.GenreNames) > 0 {
|
|
for _, v := range arg.GenreNames {
|
|
queryParams = append(queryParams, v)
|
|
}
|
|
query = strings.Replace(query, "/*SLICE:genre_names*/?", strings.Repeat(",?", len(arg.GenreNames))[1:], 1)
|
|
} else {
|
|
query = strings.Replace(query, "/*SLICE:genre_names*/?", "NULL", 1)
|
|
}
|
|
queryParams = append(queryParams, arg.LibraryID)
|
|
rows, err := q.db.QueryContext(ctx, query, queryParams...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetFilePathsByGenresByLibraryRow
|
|
for rows.Next() {
|
|
var i GetFilePathsByGenresByLibraryRow
|
|
if err := rows.Scan(&i.GenreName, &i.FilePath); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getGenresByRecordingID = `-- name: GetGenresByRecordingID :many
|
|
SELECT g.id, g.name
|
|
FROM genres g
|
|
JOIN recording_genres rg ON g.id = rg.genre_id
|
|
WHERE rg.recording_id = ?
|
|
`
|
|
|
|
func (q *Queries) GetGenresByRecordingID(ctx context.Context, recordingID int64) ([]Genre, error) {
|
|
rows, err := q.db.QueryContext(ctx, getGenresByRecordingID, recordingID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Genre
|
|
for rows.Next() {
|
|
var i Genre
|
|
if err := rows.Scan(&i.ID, &i.Name); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getTracksByGenre = `-- name: GetTracksByGenre :many
|
|
SELECT
|
|
af.file_path,
|
|
af.length_milliseconds,
|
|
COALESCE(r.name, '') AS title,
|
|
COALESCE(ac.text, '') AS artist_name,
|
|
r.track_number,
|
|
r.disc_number,
|
|
COALESCE(rlg.name, '') AS album,
|
|
CAST(COALESCE(
|
|
(SELECT GROUP_CONCAT(g2.name, '||')
|
|
FROM recording_genres rg2
|
|
JOIN genres g2 ON rg2.genre_id = g2.id
|
|
WHERE rg2.recording_id = r.id),
|
|
''
|
|
) AS TEXT) AS genre,
|
|
COALESCE(r.year, 0) AS year,
|
|
COALESCE(r.composer, '') AS composer,
|
|
COALESCE(ft.extension, '') AS file_type,
|
|
af.sample_rate,
|
|
af.bit_depth,
|
|
af.channels,
|
|
af.bitrate,
|
|
af.file_size
|
|
FROM genres g
|
|
JOIN recording_genres rg ON g.id = rg.genre_id
|
|
JOIN recordings r ON rg.recording_id = r.id
|
|
JOIN audio_files af ON af.recording_id = r.id
|
|
JOIN artist_credit ac ON r.artist_credit_id = ac.id
|
|
LEFT JOIN (
|
|
SELECT recording_id,
|
|
MIN(release_group_id) AS release_group_id
|
|
FROM release_group_recordings
|
|
GROUP BY recording_id
|
|
) rgr ON r.id = rgr.recording_id
|
|
LEFT JOIN release_groups rlg ON rgr.release_group_id = rlg.id
|
|
LEFT JOIN file_types ft ON af.file_type_id = ft.id
|
|
WHERE g.name = ?
|
|
ORDER BY r.name
|
|
`
|
|
|
|
type GetTracksByGenreRow struct {
|
|
FilePath string
|
|
LengthMilliseconds int64
|
|
Title string
|
|
ArtistName string
|
|
TrackNumber sql.NullInt64
|
|
DiscNumber sql.NullInt64
|
|
Album string
|
|
Genre string
|
|
Year int64
|
|
Composer string
|
|
FileType string
|
|
SampleRate int64
|
|
BitDepth int64
|
|
Channels int64
|
|
Bitrate int64
|
|
FileSize int64
|
|
}
|
|
|
|
func (q *Queries) GetTracksByGenre(ctx context.Context, name string) ([]GetTracksByGenreRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getTracksByGenre, name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetTracksByGenreRow
|
|
for rows.Next() {
|
|
var i GetTracksByGenreRow
|
|
if err := rows.Scan(
|
|
&i.FilePath,
|
|
&i.LengthMilliseconds,
|
|
&i.Title,
|
|
&i.ArtistName,
|
|
&i.TrackNumber,
|
|
&i.DiscNumber,
|
|
&i.Album,
|
|
&i.Genre,
|
|
&i.Year,
|
|
&i.Composer,
|
|
&i.FileType,
|
|
&i.SampleRate,
|
|
&i.BitDepth,
|
|
&i.Channels,
|
|
&i.Bitrate,
|
|
&i.FileSize,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getTracksByGenreByLibrary = `-- name: GetTracksByGenreByLibrary :many
|
|
SELECT
|
|
af.file_path,
|
|
af.length_milliseconds,
|
|
COALESCE(r.name, '') AS title,
|
|
COALESCE(ac.text, '') AS artist_name,
|
|
r.track_number,
|
|
r.disc_number,
|
|
COALESCE(rlg.name, '') AS album,
|
|
CAST(COALESCE(
|
|
(SELECT GROUP_CONCAT(g2.name, '||')
|
|
FROM recording_genres rg2
|
|
JOIN genres g2 ON rg2.genre_id = g2.id
|
|
WHERE rg2.recording_id = r.id),
|
|
''
|
|
) AS TEXT) AS genre,
|
|
COALESCE(r.year, 0) AS year,
|
|
COALESCE(r.composer, '') AS composer,
|
|
COALESCE(ft.extension, '') AS file_type,
|
|
af.sample_rate,
|
|
af.bit_depth,
|
|
af.channels,
|
|
af.bitrate,
|
|
af.file_size
|
|
FROM genres g
|
|
JOIN recording_genres rg ON g.id = rg.genre_id
|
|
JOIN recordings r ON rg.recording_id = r.id
|
|
JOIN audio_files af ON af.recording_id = r.id
|
|
JOIN artist_credit ac ON r.artist_credit_id = ac.id
|
|
LEFT JOIN (
|
|
SELECT recording_id,
|
|
MIN(release_group_id) AS release_group_id
|
|
FROM release_group_recordings
|
|
GROUP BY recording_id
|
|
) rgr ON r.id = rgr.recording_id
|
|
LEFT JOIN release_groups rlg ON rgr.release_group_id = rlg.id
|
|
LEFT JOIN file_types ft ON af.file_type_id = ft.id
|
|
WHERE g.name = ? AND af.library_id = ?
|
|
ORDER BY r.name
|
|
`
|
|
|
|
type GetTracksByGenreByLibraryParams struct {
|
|
Name string
|
|
LibraryID int64
|
|
}
|
|
|
|
type GetTracksByGenreByLibraryRow struct {
|
|
FilePath string
|
|
LengthMilliseconds int64
|
|
Title string
|
|
ArtistName string
|
|
TrackNumber sql.NullInt64
|
|
DiscNumber sql.NullInt64
|
|
Album string
|
|
Genre string
|
|
Year int64
|
|
Composer string
|
|
FileType string
|
|
SampleRate int64
|
|
BitDepth int64
|
|
Channels int64
|
|
Bitrate int64
|
|
FileSize int64
|
|
}
|
|
|
|
func (q *Queries) GetTracksByGenreByLibrary(ctx context.Context, arg GetTracksByGenreByLibraryParams) ([]GetTracksByGenreByLibraryRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getTracksByGenreByLibrary, arg.Name, arg.LibraryID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetTracksByGenreByLibraryRow
|
|
for rows.Next() {
|
|
var i GetTracksByGenreByLibraryRow
|
|
if err := rows.Scan(
|
|
&i.FilePath,
|
|
&i.LengthMilliseconds,
|
|
&i.Title,
|
|
&i.ArtistName,
|
|
&i.TrackNumber,
|
|
&i.DiscNumber,
|
|
&i.Album,
|
|
&i.Genre,
|
|
&i.Year,
|
|
&i.Composer,
|
|
&i.FileType,
|
|
&i.SampleRate,
|
|
&i.BitDepth,
|
|
&i.Channels,
|
|
&i.Bitrate,
|
|
&i.FileSize,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const upsertGenre = `-- name: UpsertGenre :one
|
|
INSERT INTO genres (name) VALUES (?)
|
|
ON CONFLICT(name) DO UPDATE SET name = name
|
|
RETURNING id, name
|
|
`
|
|
|
|
func (q *Queries) UpsertGenre(ctx context.Context, name string) (Genre, error) {
|
|
row := q.db.QueryRowContext(ctx, upsertGenre, name)
|
|
var i Genre
|
|
err := row.Scan(&i.ID, &i.Name)
|
|
return i, err
|
|
}
|