pwa-player/grpc-backend/internal/db/beatmap.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: beatmap.sql

package db

import (
	"context"
	"database/sql"
)

const getBeatmapByHash = `-- name: GetBeatmapByHash :one
SELECT beatmapid, artist, artistunicode, title, titleunicode, creator, difficulty, audio, md5hash, file, rankedstatus, lastmodifiedtime, totaltime, audiopreviewtime, beatmapsetid, source, tags, lastplayed, folder FROM Beatmap WHERE MD5Hash = ?
`

func (q *Queries) GetBeatmapByHash(ctx context.Context, md5hash sql.NullString) (Beatmap, error) {
	row := q.db.QueryRowContext(ctx, getBeatmapByHash, md5hash)
	var i Beatmap
	err := row.Scan(
		&i.Beatmapid,
		&i.Artist,
		&i.Artistunicode,
		&i.Title,
		&i.Titleunicode,
		&i.Creator,
		&i.Difficulty,
		&i.Audio,
		&i.Md5hash,
		&i.File,
		&i.Rankedstatus,
		&i.Lastmodifiedtime,
		&i.Totaltime,
		&i.Audiopreviewtime,
		&i.Beatmapsetid,
		&i.Source,
		&i.Tags,
		&i.Lastplayed,
		&i.Folder,
	)
	return i, err
}

const getBeatmapCount = `-- name: GetBeatmapCount :one
SELECT COUNT(*) FROM Beatmap
`

func (q *Queries) GetBeatmapCount(ctx context.Context) (int64, error) {
	row := q.db.QueryRowContext(ctx, getBeatmapCount)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getBeatmapSetCount = `-- name: GetBeatmapSetCount :one
SELECT COUNT(*) FROM Beatmap GROUP BY BeatmapSetId
`

func (q *Queries) GetBeatmapSetCount(ctx context.Context) (int64, error) {
	row := q.db.QueryRowContext(ctx, getBeatmapSetCount)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getRecentBeatmaps = `-- name: GetRecentBeatmaps :many
SELECT beatmapid, artist, artistunicode, title, titleunicode, creator, difficulty, audio, md5hash, file, rankedstatus, lastmodifiedtime, totaltime, audiopreviewtime, beatmapsetid, source, tags, lastplayed, folder
FROM Beatmap GROUP BY Folder ORDER BY LastModifiedTime DESC LIMIT ? OFFSET ?
`

type GetRecentBeatmapsParams struct {
	Limit  int64 `json:"limit"`
	Offset int64 `json:"offset"`
}

func (q *Queries) GetRecentBeatmaps(ctx context.Context, arg GetRecentBeatmapsParams) ([]Beatmap, error) {
	rows, err := q.db.QueryContext(ctx, getRecentBeatmaps, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Beatmap{}
	for rows.Next() {
		var i Beatmap
		if err := rows.Scan(
			&i.Beatmapid,
			&i.Artist,
			&i.Artistunicode,
			&i.Title,
			&i.Titleunicode,
			&i.Creator,
			&i.Difficulty,
			&i.Audio,
			&i.Md5hash,
			&i.File,
			&i.Rankedstatus,
			&i.Lastmodifiedtime,
			&i.Totaltime,
			&i.Audiopreviewtime,
			&i.Beatmapsetid,
			&i.Source,
			&i.Tags,
			&i.Lastplayed,
			&i.Folder,
		); 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 insertBeatmap = `-- name: InsertBeatmap :exec
INSERT INTO Beatmap (
    BeatmapId, Artist, ArtistUnicode, Title, TitleUnicode, Creator,
    Difficulty, Audio, MD5Hash, File, RankedStatus, 
    LastModifiedTime, TotalTime, AudioPreviewTime, BeatmapSetId, 
    Source, Tags, LastPlayed, Folder
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`

type InsertBeatmapParams struct {
	Beatmapid        sql.NullInt64  `json:"beatmapid"`
	Artist           sql.NullString `json:"artist"`
	Artistunicode    sql.NullString `json:"artistunicode"`
	Title            sql.NullString `json:"title"`
	Titleunicode     sql.NullString `json:"titleunicode"`
	Creator          sql.NullString `json:"creator"`
	Difficulty       sql.NullString `json:"difficulty"`
	Audio            sql.NullString `json:"audio"`
	Md5hash          sql.NullString `json:"md5hash"`
	File             sql.NullString `json:"file"`
	Rankedstatus     sql.NullString `json:"rankedstatus"`
	Lastmodifiedtime sql.NullInt64  `json:"lastmodifiedtime"`
	Totaltime        sql.NullInt64  `json:"totaltime"`
	Audiopreviewtime sql.NullInt64  `json:"audiopreviewtime"`
	Beatmapsetid     sql.NullInt64  `json:"beatmapsetid"`
	Source           sql.NullString `json:"source"`
	Tags             sql.NullString `json:"tags"`
	Lastplayed       sql.NullInt64  `json:"lastplayed"`
	Folder           sql.NullString `json:"folder"`
}

func (q *Queries) InsertBeatmap(ctx context.Context, arg InsertBeatmapParams) error {
	_, err := q.db.ExecContext(ctx, insertBeatmap,
		arg.Beatmapid,
		arg.Artist,
		arg.Artistunicode,
		arg.Title,
		arg.Titleunicode,
		arg.Creator,
		arg.Difficulty,
		arg.Audio,
		arg.Md5hash,
		arg.File,
		arg.Rankedstatus,
		arg.Lastmodifiedtime,
		arg.Totaltime,
		arg.Audiopreviewtime,
		arg.Beatmapsetid,
		arg.Source,
		arg.Tags,
		arg.Lastplayed,
		arg.Folder,
	)
	return err
}

const searchArtists = `-- name: SearchArtists :many
SELECT Artist, COUNT(Artist) AS count
FROM Beatmap 
WHERE Artist LIKE ? OR Title LIKE ?
GROUP BY Artist 
LIMIT ? OFFSET ?
`

type SearchArtistsParams struct {
	Artist sql.NullString `json:"artist"`
	Title  sql.NullString `json:"title"`
	Limit  int64          `json:"limit"`
	Offset int64          `json:"offset"`
}

type SearchArtistsRow struct {
	Artist sql.NullString `json:"artist"`
	Count  int64          `json:"count"`
}

func (q *Queries) SearchArtists(ctx context.Context, arg SearchArtistsParams) ([]SearchArtistsRow, error) {
	rows, err := q.db.QueryContext(ctx, searchArtists,
		arg.Artist,
		arg.Title,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []SearchArtistsRow{}
	for rows.Next() {
		var i SearchArtistsRow
		if err := rows.Scan(&i.Artist, &i.Count); 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 searchBeatmaps = `-- name: SearchBeatmaps :many
SELECT beatmapid, artist, artistunicode, title, titleunicode, creator, difficulty, audio, md5hash, file, rankedstatus, lastmodifiedtime, totaltime, audiopreviewtime, beatmapsetid, source, tags, lastplayed, folder 
FROM Beatmap 
WHERE Title LIKE ? OR Artist LIKE ?
GROUP BY Folder
LIMIT ? OFFSET ?
`

type SearchBeatmapsParams struct {
	Title  sql.NullString `json:"title"`
	Artist sql.NullString `json:"artist"`
	Limit  int64          `json:"limit"`
	Offset int64          `json:"offset"`
}

func (q *Queries) SearchBeatmaps(ctx context.Context, arg SearchBeatmapsParams) ([]Beatmap, error) {
	rows, err := q.db.QueryContext(ctx, searchBeatmaps,
		arg.Title,
		arg.Artist,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Beatmap{}
	for rows.Next() {
		var i Beatmap
		if err := rows.Scan(
			&i.Beatmapid,
			&i.Artist,
			&i.Artistunicode,
			&i.Title,
			&i.Titleunicode,
			&i.Creator,
			&i.Difficulty,
			&i.Audio,
			&i.Md5hash,
			&i.File,
			&i.Rankedstatus,
			&i.Lastmodifiedtime,
			&i.Totaltime,
			&i.Audiopreviewtime,
			&i.Beatmapsetid,
			&i.Source,
			&i.Tags,
			&i.Lastplayed,
			&i.Folder,
		); 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
}