SansanandClaude Opus 5.5
bb8de5548d
Alternative names (#32): - PUT /api/v1/soundtracks/{uuid}/alternative-names replaces a soundtrack's alternative names (trimmed, deduplicated, without the soundtrack's own name). - alternative_names is in the soundtrack and statistics responses. - /find matches them too and shows which name matched. Covers (#12), stored in COVERS_PATH and off when it is not set: - GET, PUT (upload) and DELETE /api/v1/soundtracks/{uuid}/cover, and PUT .../cover/source to pick a SteamGridDB game or AniList anime by ID. Uploaded and picked covers are never replaced automatically. - With STEAMGRIDDB_API_KEY, a background job searches SteamGridDB, then AniList, by name, alternative names and the name without bracketed parts, at startup, after a sync and after names change. Search results are ranked by matching words, so "Civilization IV" gets "Sid Meier's Civilization IV". - cover_modified (Unix seconds) is in the soundtrack and statistics responses, so clients can cache covers. The new columns are added to migration 000006, which is not released yet. Closes #12, closes #32 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
610 lines
18 KiB
Go
610 lines
18 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: statistics.sql
|
|
|
|
package repository
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const countLibrary = `-- name: CountLibrary :one
|
|
SELECT
|
|
(SELECT COUNT(*) FROM soundtrack WHERE deleted IS NULL) AS soundtracks,
|
|
(SELECT COUNT(*) FROM song s JOIN soundtrack st ON st.id = s.soundtrack_id WHERE st.deleted IS NULL) AS songs
|
|
`
|
|
|
|
type CountLibraryRow struct {
|
|
Soundtracks int64 `json:"soundtracks"`
|
|
Songs int64 `json:"songs"`
|
|
}
|
|
|
|
// Soundtracks and songs in the library, without deleted soundtracks.
|
|
func (q *Queries) CountLibrary(ctx context.Context) (CountLibraryRow, error) {
|
|
row := q.db.QueryRow(ctx, countLibrary)
|
|
var i CountLibraryRow
|
|
err := row.Scan(&i.Soundtracks, &i.Songs)
|
|
return i, err
|
|
}
|
|
|
|
const getAllSoundtracksWithSongs = `-- name: GetAllSoundtracksWithSongs :many
|
|
SELECT
|
|
g.id as soundtrack_id,
|
|
g.uuid as soundtrack_uuid,
|
|
g.soundtrack_name,
|
|
g.times_played as soundtrack_played,
|
|
g.alternative_names,
|
|
g.cover_modified,
|
|
g.last_played as soundtrack_last_played,
|
|
COALESCE(
|
|
json_agg(
|
|
json_build_object(
|
|
'song_uuid', s.uuid,
|
|
'soundtrack_uuid', g.uuid,
|
|
'song_name', s.song_name,
|
|
'path', s.path,
|
|
'times_played', s.times_played,
|
|
'file_name', s.file_name
|
|
)
|
|
) FILTER (WHERE s.uuid IS NOT NULL),
|
|
'[]'
|
|
)::json as songs
|
|
FROM soundtrack g
|
|
LEFT JOIN song s ON g.id = s.soundtrack_id
|
|
WHERE g.deleted IS NULL
|
|
GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
|
|
ORDER BY g.soundtrack_name
|
|
`
|
|
|
|
type GetAllSoundtracksWithSongsRow struct {
|
|
SoundtrackID int32 `json:"soundtrack_id"`
|
|
SoundtrackUuid uuid.UUID `json:"soundtrack_uuid"`
|
|
SoundtrackName string `json:"soundtrack_name"`
|
|
SoundtrackPlayed int32 `json:"soundtrack_played"`
|
|
AlternativeNames []string `json:"alternative_names"`
|
|
CoverModified pgtype.Timestamptz `json:"cover_modified"`
|
|
SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
|
|
Songs []byte `json:"songs"`
|
|
}
|
|
|
|
// Every soundtrack with its songs, by name
|
|
func (q *Queries) GetAllSoundtracksWithSongs(ctx context.Context) ([]GetAllSoundtracksWithSongsRow, error) {
|
|
rows, err := q.db.Query(ctx, getAllSoundtracksWithSongs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetAllSoundtracksWithSongsRow
|
|
for rows.Next() {
|
|
var i GetAllSoundtracksWithSongsRow
|
|
if err := rows.Scan(
|
|
&i.SoundtrackID,
|
|
&i.SoundtrackUuid,
|
|
&i.SoundtrackName,
|
|
&i.SoundtrackPlayed,
|
|
&i.AlternativeNames,
|
|
&i.CoverModified,
|
|
&i.SoundtrackLastPlayed,
|
|
&i.Songs,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getLastPlayedSoundtracks = `-- name: GetLastPlayedSoundtracks :many
|
|
SELECT
|
|
g.id as soundtrack_id,
|
|
g.uuid as soundtrack_uuid,
|
|
g.soundtrack_name,
|
|
g.times_played as soundtrack_played,
|
|
g.alternative_names,
|
|
g.cover_modified,
|
|
g.last_played as soundtrack_last_played,
|
|
COALESCE(
|
|
json_agg(
|
|
json_build_object(
|
|
'song_uuid', s.uuid,
|
|
'soundtrack_uuid', g.uuid,
|
|
'song_name', s.song_name,
|
|
'path', s.path,
|
|
'times_played', s.times_played
|
|
)
|
|
) FILTER (WHERE s.uuid IS NOT NULL),
|
|
'[]'
|
|
)::json as songs
|
|
FROM soundtrack g
|
|
LEFT JOIN song s ON g.id = s.soundtrack_id
|
|
WHERE g.deleted IS NULL AND g.last_played IS NOT NULL
|
|
GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
|
|
ORDER BY g.last_played DESC
|
|
LIMIT $1
|
|
`
|
|
|
|
type GetLastPlayedSoundtracksRow struct {
|
|
SoundtrackID int32 `json:"soundtrack_id"`
|
|
SoundtrackUuid uuid.UUID `json:"soundtrack_uuid"`
|
|
SoundtrackName string `json:"soundtrack_name"`
|
|
SoundtrackPlayed int32 `json:"soundtrack_played"`
|
|
AlternativeNames []string `json:"alternative_names"`
|
|
CoverModified pgtype.Timestamptz `json:"cover_modified"`
|
|
SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
|
|
Songs []byte `json:"songs"`
|
|
}
|
|
|
|
// Last played soundtracks (most recently played)
|
|
func (q *Queries) GetLastPlayedSoundtracks(ctx context.Context, limit int32) ([]GetLastPlayedSoundtracksRow, error) {
|
|
rows, err := q.db.Query(ctx, getLastPlayedSoundtracks, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetLastPlayedSoundtracksRow
|
|
for rows.Next() {
|
|
var i GetLastPlayedSoundtracksRow
|
|
if err := rows.Scan(
|
|
&i.SoundtrackID,
|
|
&i.SoundtrackUuid,
|
|
&i.SoundtrackName,
|
|
&i.SoundtrackPlayed,
|
|
&i.AlternativeNames,
|
|
&i.CoverModified,
|
|
&i.SoundtrackLastPlayed,
|
|
&i.Songs,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getLeastPlayedSongsWithSoundtrack = `-- name: GetLeastPlayedSongsWithSoundtrack :many
|
|
SELECT
|
|
s.soundtrack_id as soundtrack_id,
|
|
g.uuid as soundtrack_uuid,
|
|
s.uuid as song_uuid,
|
|
g.soundtrack_name,
|
|
s.song_name,
|
|
s.path,
|
|
s.times_played,
|
|
s.file_name
|
|
FROM song s
|
|
JOIN soundtrack g ON s.soundtrack_id = g.id
|
|
WHERE g.deleted IS NULL
|
|
ORDER BY s.times_played ASC, s.song_name
|
|
LIMIT $1
|
|
`
|
|
|
|
type GetLeastPlayedSongsWithSoundtrackRow struct {
|
|
SoundtrackID int32 `json:"soundtrack_id"`
|
|
SoundtrackUuid uuid.UUID `json:"soundtrack_uuid"`
|
|
SongUuid uuid.UUID `json:"song_uuid"`
|
|
SoundtrackName string `json:"soundtrack_name"`
|
|
SongName string `json:"song_name"`
|
|
Path string `json:"path"`
|
|
TimesPlayed int32 `json:"times_played"`
|
|
FileName *string `json:"file_name"`
|
|
}
|
|
|
|
// Least played songs with their soundtrack info
|
|
func (q *Queries) GetLeastPlayedSongsWithSoundtrack(ctx context.Context, limit int32) ([]GetLeastPlayedSongsWithSoundtrackRow, error) {
|
|
rows, err := q.db.Query(ctx, getLeastPlayedSongsWithSoundtrack, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetLeastPlayedSongsWithSoundtrackRow
|
|
for rows.Next() {
|
|
var i GetLeastPlayedSongsWithSoundtrackRow
|
|
if err := rows.Scan(
|
|
&i.SoundtrackID,
|
|
&i.SoundtrackUuid,
|
|
&i.SongUuid,
|
|
&i.SoundtrackName,
|
|
&i.SongName,
|
|
&i.Path,
|
|
&i.TimesPlayed,
|
|
&i.FileName,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getLeastPlayedSoundtracksWithSongs = `-- name: GetLeastPlayedSoundtracksWithSongs :many
|
|
SELECT
|
|
g.id as soundtrack_id,
|
|
g.uuid as soundtrack_uuid,
|
|
g.soundtrack_name,
|
|
g.times_played as soundtrack_played,
|
|
g.alternative_names,
|
|
g.cover_modified,
|
|
g.last_played as soundtrack_last_played,
|
|
COALESCE(
|
|
json_agg(
|
|
json_build_object(
|
|
'song_uuid', s.uuid,
|
|
'soundtrack_uuid', g.uuid,
|
|
'song_name', s.song_name,
|
|
'path', s.path,
|
|
'times_played', s.times_played,
|
|
'file_name', s.file_name
|
|
)
|
|
) FILTER (WHERE s.uuid IS NOT NULL),
|
|
'[]'
|
|
)::json as songs
|
|
FROM soundtrack g
|
|
LEFT JOIN song s ON g.id = s.soundtrack_id
|
|
WHERE g.deleted IS NULL
|
|
GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
|
|
ORDER BY g.times_played ASC, g.soundtrack_name
|
|
LIMIT $1
|
|
`
|
|
|
|
type GetLeastPlayedSoundtracksWithSongsRow struct {
|
|
SoundtrackID int32 `json:"soundtrack_id"`
|
|
SoundtrackUuid uuid.UUID `json:"soundtrack_uuid"`
|
|
SoundtrackName string `json:"soundtrack_name"`
|
|
SoundtrackPlayed int32 `json:"soundtrack_played"`
|
|
AlternativeNames []string `json:"alternative_names"`
|
|
CoverModified pgtype.Timestamptz `json:"cover_modified"`
|
|
SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
|
|
Songs []byte `json:"songs"`
|
|
}
|
|
|
|
// Least played soundtracks with their songs
|
|
func (q *Queries) GetLeastPlayedSoundtracksWithSongs(ctx context.Context, limit int32) ([]GetLeastPlayedSoundtracksWithSongsRow, error) {
|
|
rows, err := q.db.Query(ctx, getLeastPlayedSoundtracksWithSongs, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetLeastPlayedSoundtracksWithSongsRow
|
|
for rows.Next() {
|
|
var i GetLeastPlayedSoundtracksWithSongsRow
|
|
if err := rows.Scan(
|
|
&i.SoundtrackID,
|
|
&i.SoundtrackUuid,
|
|
&i.SoundtrackName,
|
|
&i.SoundtrackPlayed,
|
|
&i.AlternativeNames,
|
|
&i.CoverModified,
|
|
&i.SoundtrackLastPlayed,
|
|
&i.Songs,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getMostPlayedSongsWithSoundtrack = `-- name: GetMostPlayedSongsWithSoundtrack :many
|
|
SELECT
|
|
s.soundtrack_id as soundtrack_id,
|
|
g.uuid as soundtrack_uuid,
|
|
s.uuid as song_uuid,
|
|
g.soundtrack_name,
|
|
s.song_name,
|
|
s.path,
|
|
s.times_played,
|
|
s.file_name
|
|
FROM song s
|
|
JOIN soundtrack g ON s.soundtrack_id = g.id
|
|
WHERE g.deleted IS NULL
|
|
ORDER BY s.times_played DESC, s.song_name
|
|
LIMIT $1
|
|
`
|
|
|
|
type GetMostPlayedSongsWithSoundtrackRow struct {
|
|
SoundtrackID int32 `json:"soundtrack_id"`
|
|
SoundtrackUuid uuid.UUID `json:"soundtrack_uuid"`
|
|
SongUuid uuid.UUID `json:"song_uuid"`
|
|
SoundtrackName string `json:"soundtrack_name"`
|
|
SongName string `json:"song_name"`
|
|
Path string `json:"path"`
|
|
TimesPlayed int32 `json:"times_played"`
|
|
FileName *string `json:"file_name"`
|
|
}
|
|
|
|
// Most played songs with their soundtrack info
|
|
func (q *Queries) GetMostPlayedSongsWithSoundtrack(ctx context.Context, limit int32) ([]GetMostPlayedSongsWithSoundtrackRow, error) {
|
|
rows, err := q.db.Query(ctx, getMostPlayedSongsWithSoundtrack, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetMostPlayedSongsWithSoundtrackRow
|
|
for rows.Next() {
|
|
var i GetMostPlayedSongsWithSoundtrackRow
|
|
if err := rows.Scan(
|
|
&i.SoundtrackID,
|
|
&i.SoundtrackUuid,
|
|
&i.SongUuid,
|
|
&i.SoundtrackName,
|
|
&i.SongName,
|
|
&i.Path,
|
|
&i.TimesPlayed,
|
|
&i.FileName,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getMostPlayedSoundtracksWithSongs = `-- name: GetMostPlayedSoundtracksWithSongs :many
|
|
SELECT
|
|
g.id as soundtrack_id,
|
|
g.uuid as soundtrack_uuid,
|
|
g.soundtrack_name,
|
|
g.times_played as soundtrack_played,
|
|
g.alternative_names,
|
|
g.cover_modified,
|
|
g.last_played as soundtrack_last_played,
|
|
COALESCE(
|
|
json_agg(
|
|
json_build_object(
|
|
'song_uuid', s.uuid,
|
|
'soundtrack_uuid', g.uuid,
|
|
'song_name', s.song_name,
|
|
'path', s.path,
|
|
'times_played', s.times_played,
|
|
'file_name', s.file_name
|
|
)
|
|
) FILTER (WHERE s.uuid IS NOT NULL),
|
|
'[]'
|
|
)::json as songs
|
|
FROM soundtrack g
|
|
LEFT JOIN song s ON g.id = s.soundtrack_id
|
|
WHERE g.deleted IS NULL
|
|
GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
|
|
ORDER BY g.times_played DESC, g.soundtrack_name
|
|
LIMIT $1
|
|
`
|
|
|
|
type GetMostPlayedSoundtracksWithSongsRow struct {
|
|
SoundtrackID int32 `json:"soundtrack_id"`
|
|
SoundtrackUuid uuid.UUID `json:"soundtrack_uuid"`
|
|
SoundtrackName string `json:"soundtrack_name"`
|
|
SoundtrackPlayed int32 `json:"soundtrack_played"`
|
|
AlternativeNames []string `json:"alternative_names"`
|
|
CoverModified pgtype.Timestamptz `json:"cover_modified"`
|
|
SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
|
|
Songs []byte `json:"songs"`
|
|
}
|
|
|
|
// Most played soundtracks with their songs
|
|
func (q *Queries) GetMostPlayedSoundtracksWithSongs(ctx context.Context, limit int32) ([]GetMostPlayedSoundtracksWithSongsRow, error) {
|
|
rows, err := q.db.Query(ctx, getMostPlayedSoundtracksWithSongs, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetMostPlayedSoundtracksWithSongsRow
|
|
for rows.Next() {
|
|
var i GetMostPlayedSoundtracksWithSongsRow
|
|
if err := rows.Scan(
|
|
&i.SoundtrackID,
|
|
&i.SoundtrackUuid,
|
|
&i.SoundtrackName,
|
|
&i.SoundtrackPlayed,
|
|
&i.AlternativeNames,
|
|
&i.CoverModified,
|
|
&i.SoundtrackLastPlayed,
|
|
&i.Songs,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getNeverPlayedSoundtracks = `-- name: GetNeverPlayedSoundtracks :many
|
|
SELECT
|
|
g.id as soundtrack_id,
|
|
g.uuid as soundtrack_uuid,
|
|
g.soundtrack_name,
|
|
g.times_played as soundtrack_played,
|
|
g.alternative_names,
|
|
g.cover_modified,
|
|
g.added,
|
|
COALESCE(
|
|
json_agg(
|
|
json_build_object(
|
|
'song_uuid', s.uuid,
|
|
'soundtrack_uuid', g.uuid,
|
|
'song_name', s.song_name,
|
|
'path', s.path,
|
|
'times_played', s.times_played
|
|
)
|
|
) FILTER (WHERE s.uuid IS NOT NULL),
|
|
'[]'
|
|
)::json as songs
|
|
FROM soundtrack g
|
|
LEFT JOIN song s ON g.id = s.soundtrack_id
|
|
WHERE g.deleted IS NULL AND g.times_played = 0
|
|
GROUP BY g.id, g.soundtrack_name, g.times_played, g.added
|
|
ORDER BY g.soundtrack_name
|
|
`
|
|
|
|
type GetNeverPlayedSoundtracksRow struct {
|
|
SoundtrackID int32 `json:"soundtrack_id"`
|
|
SoundtrackUuid uuid.UUID `json:"soundtrack_uuid"`
|
|
SoundtrackName string `json:"soundtrack_name"`
|
|
SoundtrackPlayed int32 `json:"soundtrack_played"`
|
|
AlternativeNames []string `json:"alternative_names"`
|
|
CoverModified pgtype.Timestamptz `json:"cover_modified"`
|
|
Added time.Time `json:"added"`
|
|
Songs []byte `json:"songs"`
|
|
}
|
|
|
|
// Soundtracks that have never been played (times_played = 0)
|
|
func (q *Queries) GetNeverPlayedSoundtracks(ctx context.Context) ([]GetNeverPlayedSoundtracksRow, error) {
|
|
rows, err := q.db.Query(ctx, getNeverPlayedSoundtracks)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetNeverPlayedSoundtracksRow
|
|
for rows.Next() {
|
|
var i GetNeverPlayedSoundtracksRow
|
|
if err := rows.Scan(
|
|
&i.SoundtrackID,
|
|
&i.SoundtrackUuid,
|
|
&i.SoundtrackName,
|
|
&i.SoundtrackPlayed,
|
|
&i.AlternativeNames,
|
|
&i.CoverModified,
|
|
&i.Added,
|
|
&i.Songs,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getOldestPlayedSoundtracks = `-- name: GetOldestPlayedSoundtracks :many
|
|
SELECT
|
|
g.id as soundtrack_id,
|
|
g.uuid as soundtrack_uuid,
|
|
g.soundtrack_name,
|
|
g.times_played as soundtrack_played,
|
|
g.alternative_names,
|
|
g.cover_modified,
|
|
g.last_played as soundtrack_last_played,
|
|
COALESCE(
|
|
json_agg(
|
|
json_build_object(
|
|
'song_uuid', s.uuid,
|
|
'soundtrack_uuid', g.uuid,
|
|
'song_name', s.song_name,
|
|
'path', s.path,
|
|
'times_played', s.times_played
|
|
)
|
|
) FILTER (WHERE s.uuid IS NOT NULL),
|
|
'[]'
|
|
)::json as songs
|
|
FROM soundtrack g
|
|
LEFT JOIN song s ON g.id = s.soundtrack_id
|
|
WHERE g.deleted IS NULL AND g.last_played IS NOT NULL
|
|
GROUP BY g.id, g.soundtrack_name, g.times_played, g.last_played
|
|
ORDER BY g.last_played ASC
|
|
LIMIT $1
|
|
`
|
|
|
|
type GetOldestPlayedSoundtracksRow struct {
|
|
SoundtrackID int32 `json:"soundtrack_id"`
|
|
SoundtrackUuid uuid.UUID `json:"soundtrack_uuid"`
|
|
SoundtrackName string `json:"soundtrack_name"`
|
|
SoundtrackPlayed int32 `json:"soundtrack_played"`
|
|
AlternativeNames []string `json:"alternative_names"`
|
|
CoverModified pgtype.Timestamptz `json:"cover_modified"`
|
|
SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
|
|
Songs []byte `json:"songs"`
|
|
}
|
|
|
|
// Oldest played soundtracks (least recently played, but has been played at least once)
|
|
func (q *Queries) GetOldestPlayedSoundtracks(ctx context.Context, limit int32) ([]GetOldestPlayedSoundtracksRow, error) {
|
|
rows, err := q.db.Query(ctx, getOldestPlayedSoundtracks, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetOldestPlayedSoundtracksRow
|
|
for rows.Next() {
|
|
var i GetOldestPlayedSoundtracksRow
|
|
if err := rows.Scan(
|
|
&i.SoundtrackID,
|
|
&i.SoundtrackUuid,
|
|
&i.SoundtrackName,
|
|
&i.SoundtrackPlayed,
|
|
&i.AlternativeNames,
|
|
&i.CoverModified,
|
|
&i.SoundtrackLastPlayed,
|
|
&i.Songs,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getStatisticsSummary = `-- name: GetStatisticsSummary :one
|
|
SELECT
|
|
COUNT(*) as total_soundtracks,
|
|
COALESCE(SUM(CASE WHEN times_played > 0 THEN 1 ELSE 0 END), 0)::bigint as played_soundtracks,
|
|
COALESCE(SUM(CASE WHEN times_played = 0 THEN 1 ELSE 0 END), 0)::bigint as never_played_soundtracks,
|
|
COALESCE(SUM(times_played), 0)::bigint as total_soundtrack_plays,
|
|
COALESCE(AVG(times_played), 0)::float as avg_soundtrack_plays,
|
|
COALESCE(MAX(times_played), 0)::bigint as max_soundtrack_plays,
|
|
COALESCE(MIN(times_played), 0)::bigint as min_soundtrack_plays
|
|
FROM soundtrack
|
|
WHERE deleted IS NULL
|
|
`
|
|
|
|
type GetStatisticsSummaryRow struct {
|
|
TotalSoundtracks int64 `json:"total_soundtracks"`
|
|
PlayedSoundtracks int64 `json:"played_soundtracks"`
|
|
NeverPlayedSoundtracks int64 `json:"never_played_soundtracks"`
|
|
TotalSoundtrackPlays int64 `json:"total_soundtrack_plays"`
|
|
AvgSoundtrackPlays float64 `json:"avg_soundtrack_plays"`
|
|
MaxSoundtrackPlays int64 `json:"max_soundtrack_plays"`
|
|
MinSoundtrackPlays int64 `json:"min_soundtrack_plays"`
|
|
}
|
|
|
|
// Get statistics summary
|
|
func (q *Queries) GetStatisticsSummary(ctx context.Context) (GetStatisticsSummaryRow, error) {
|
|
row := q.db.QueryRow(ctx, getStatisticsSummary)
|
|
var i GetStatisticsSummaryRow
|
|
err := row.Scan(
|
|
&i.TotalSoundtracks,
|
|
&i.PlayedSoundtracks,
|
|
&i.NeverPlayedSoundtracks,
|
|
&i.TotalSoundtrackPlays,
|
|
&i.AvgSoundtrackPlays,
|
|
&i.MaxSoundtrackPlays,
|
|
&i.MinSoundtrackPlays,
|
|
)
|
|
return i, err
|
|
}
|