MusicServer/internal/db/repository/statistics.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: statistics.sql

package repository

import (
	"context"
	"time"
)

const getLastPlayedGames = `-- name: GetLastPlayedGames :many
SELECT 
    g.id as soundtrack_id,
    g.soundtrack_name,
    g.times_played as soundtrack_played,
    g.last_played as soundtrack_last_played,
    json_agg(
        json_build_object(
            'song_name', s.song_name,
            'path', s.path,
            'times_played', s.times_played
        )
    ) 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 GetLastPlayedGamesRow struct {
	SoundtrackID         int32      `json:"soundtrack_id"`
	SoundtrackName       string     `json:"soundtrack_name"`
	SoundtrackPlayed     int32      `json:"soundtrack_played"`
	SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
	Songs                []byte     `json:"songs"`
}

// Last played soundtracks (most recently played)
func (q *Queries) GetLastPlayedGames(ctx context.Context, limit int32) ([]GetLastPlayedGamesRow, error) {
	rows, err := q.db.Query(ctx, getLastPlayedGames, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetLastPlayedGamesRow
	for rows.Next() {
		var i GetLastPlayedGamesRow
		if err := rows.Scan(
			&i.SoundtrackID,
			&i.SoundtrackName,
			&i.SoundtrackPlayed,
			&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 getLeastPlayedGamesWithSongs = `-- name: GetLeastPlayedGamesWithSongs :many
SELECT 
    g.id as soundtrack_id,
    g.soundtrack_name,
    g.times_played as soundtrack_played,
    g.last_played as soundtrack_last_played,
    json_agg(
        json_build_object(
            'song_name', s.song_name,
            'path', s.path,
            'times_played', s.times_played,
            'file_name', s.file_name
        )
    ) 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 GetLeastPlayedGamesWithSongsRow struct {
	SoundtrackID         int32      `json:"soundtrack_id"`
	SoundtrackName       string     `json:"soundtrack_name"`
	SoundtrackPlayed     int32      `json:"soundtrack_played"`
	SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
	Songs                []byte     `json:"songs"`
}

// Least played soundtracks with their songs
func (q *Queries) GetLeastPlayedGamesWithSongs(ctx context.Context, limit int32) ([]GetLeastPlayedGamesWithSongsRow, error) {
	rows, err := q.db.Query(ctx, getLeastPlayedGamesWithSongs, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetLeastPlayedGamesWithSongsRow
	for rows.Next() {
		var i GetLeastPlayedGamesWithSongsRow
		if err := rows.Scan(
			&i.SoundtrackID,
			&i.SoundtrackName,
			&i.SoundtrackPlayed,
			&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 getLeastPlayedSongsWithGame = `-- name: GetLeastPlayedSongsWithGame :many
SELECT 
    s.soundtrack_id as soundtrack_id,
    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 GetLeastPlayedSongsWithGameRow struct {
	SoundtrackID   int32   `json:"soundtrack_id"`
	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) GetLeastPlayedSongsWithGame(ctx context.Context, limit int32) ([]GetLeastPlayedSongsWithGameRow, error) {
	rows, err := q.db.Query(ctx, getLeastPlayedSongsWithGame, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetLeastPlayedSongsWithGameRow
	for rows.Next() {
		var i GetLeastPlayedSongsWithGameRow
		if err := rows.Scan(
			&i.SoundtrackID,
			&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 getMostPlayedGamesWithSongs = `-- name: GetMostPlayedGamesWithSongs :many
SELECT 
    g.id as soundtrack_id,
    g.soundtrack_name,
    g.times_played as soundtrack_played,
    g.last_played as soundtrack_last_played,
    json_agg(
        json_build_object(
            'song_name', s.song_name,
            'path', s.path,
            'times_played', s.times_played,
            'file_name', s.file_name
        )
    ) 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 GetMostPlayedGamesWithSongsRow struct {
	SoundtrackID         int32      `json:"soundtrack_id"`
	SoundtrackName       string     `json:"soundtrack_name"`
	SoundtrackPlayed     int32      `json:"soundtrack_played"`
	SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played"`
	Songs                []byte     `json:"songs"`
}

// Most played soundtracks with their songs
func (q *Queries) GetMostPlayedGamesWithSongs(ctx context.Context, limit int32) ([]GetMostPlayedGamesWithSongsRow, error) {
	rows, err := q.db.Query(ctx, getMostPlayedGamesWithSongs, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetMostPlayedGamesWithSongsRow
	for rows.Next() {
		var i GetMostPlayedGamesWithSongsRow
		if err := rows.Scan(
			&i.SoundtrackID,
			&i.SoundtrackName,
			&i.SoundtrackPlayed,
			&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 getMostPlayedSongsWithGame = `-- name: GetMostPlayedSongsWithGame :many
SELECT 
    s.soundtrack_id as soundtrack_id,
    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 GetMostPlayedSongsWithGameRow struct {
	SoundtrackID   int32   `json:"soundtrack_id"`
	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) GetMostPlayedSongsWithGame(ctx context.Context, limit int32) ([]GetMostPlayedSongsWithGameRow, error) {
	rows, err := q.db.Query(ctx, getMostPlayedSongsWithGame, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetMostPlayedSongsWithGameRow
	for rows.Next() {
		var i GetMostPlayedSongsWithGameRow
		if err := rows.Scan(
			&i.SoundtrackID,
			&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 getNeverPlayedGames = `-- name: GetNeverPlayedGames :many
SELECT 
    g.id as soundtrack_id,
    g.soundtrack_name,
    g.times_played as soundtrack_played,
    g.added,
    json_agg(
        json_build_object(
            'song_name', s.song_name,
            'path', s.path,
            'times_played', s.times_played
        )
    ) 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 GetNeverPlayedGamesRow struct {
	SoundtrackID     int32     `json:"soundtrack_id"`
	SoundtrackName   string    `json:"soundtrack_name"`
	SoundtrackPlayed int32     `json:"soundtrack_played"`
	Added            time.Time `json:"added"`
	Songs            []byte    `json:"songs"`
}

// Games that have never been played (times_played = 0)
func (q *Queries) GetNeverPlayedGames(ctx context.Context) ([]GetNeverPlayedGamesRow, error) {
	rows, err := q.db.Query(ctx, getNeverPlayedGames)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetNeverPlayedGamesRow
	for rows.Next() {
		var i GetNeverPlayedGamesRow
		if err := rows.Scan(
			&i.SoundtrackID,
			&i.SoundtrackName,
			&i.SoundtrackPlayed,
			&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 getOldestPlayedGames = `-- name: GetOldestPlayedGames :many
SELECT 
    g.id as soundtrack_id,
    g.soundtrack_name,
    g.times_played as soundtrack_played,
    g.last_played as soundtrack_last_played,
    json_agg(
        json_build_object(
            'song_name', s.song_name,
            'path', s.path,
            'times_played', s.times_played
        )
    ) 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 GetOldestPlayedGamesRow struct {
	SoundtrackID         int32      `json:"soundtrack_id"`
	SoundtrackName       string     `json:"soundtrack_name"`
	SoundtrackPlayed     int32      `json:"soundtrack_played"`
	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) GetOldestPlayedGames(ctx context.Context, limit int32) ([]GetOldestPlayedGamesRow, error) {
	rows, err := q.db.Query(ctx, getOldestPlayedGames, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetOldestPlayedGamesRow
	for rows.Next() {
		var i GetOldestPlayedGamesRow
		if err := rows.Scan(
			&i.SoundtrackID,
			&i.SoundtrackName,
			&i.SoundtrackPlayed,
			&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,
    SUM(CASE WHEN times_played > 0 THEN 1 ELSE 0 END) as played_soundtracks,
    SUM(CASE WHEN times_played = 0 THEN 1 ELSE 0 END) 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
}