You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
465 lines
16 KiB
465 lines
16 KiB
import Foundation
|
|
import GRDB
|
|
|
|
// `nonisolated` opts this struct out of the project-wide `default-isolation = MainActor`.
|
|
nonisolated struct MonthlyCount: Sendable {
|
|
let month: Date
|
|
let count: Int
|
|
}
|
|
|
|
// `nonisolated` opts this class out of the project-wide `default-isolation = MainActor`
|
|
// setting so database operations run off the main actor and can be used from Sendable contexts.
|
|
nonisolated final class DatabaseService: Sendable {
|
|
let dbPool: DatabaseWriter
|
|
|
|
init(path: String) throws {
|
|
let dbPool = try DatabasePool(path: path)
|
|
self.dbPool = dbPool
|
|
try Self.migrate(dbPool)
|
|
}
|
|
|
|
init(inMemory: Bool) throws {
|
|
let dbQueue = try DatabaseQueue()
|
|
self.dbPool = dbQueue
|
|
try Self.migrate(dbQueue)
|
|
}
|
|
|
|
private static func migrate(_ db: DatabaseWriter) throws {
|
|
var migrator = DatabaseMigrator()
|
|
|
|
migrator.registerMigration("v1-create-tracks") { db in
|
|
try db.create(table: "tracks") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("fileURL", .text).notNull().unique()
|
|
t.column("title", .text).notNull()
|
|
t.column("artist", .text).notNull()
|
|
t.column("albumArtist", .text).notNull()
|
|
t.column("album", .text).notNull()
|
|
t.column("genre", .text).notNull()
|
|
t.column("year", .integer)
|
|
t.column("trackNumber", .integer)
|
|
t.column("discNumber", .integer)
|
|
t.column("duration", .double).notNull()
|
|
t.column("bpm", .integer)
|
|
t.column("composer", .text).notNull()
|
|
t.column("fileFormat", .text).notNull()
|
|
t.column("bitrate", .integer)
|
|
t.column("sampleRate", .integer)
|
|
t.column("fileSize", .integer).notNull()
|
|
t.column("artworkData", .blob)
|
|
t.column("playCount", .integer).notNull().defaults(to: 0)
|
|
t.column("lastPlayedAt", .datetime)
|
|
t.column("rating", .integer).notNull().defaults(to: 0)
|
|
t.column("dateAdded", .datetime).notNull()
|
|
t.column("dateModified", .datetime).notNull()
|
|
t.column("fileHash", .text).notNull()
|
|
}
|
|
|
|
try db.create(index: "idx_tracks_artist", on: "tracks", columns: ["artist"])
|
|
try db.create(index: "idx_tracks_album", on: "tracks", columns: ["album"])
|
|
try db.create(index: "idx_tracks_genre", on: "tracks", columns: ["genre"])
|
|
try db.create(index: "idx_tracks_year", on: "tracks", columns: ["year"])
|
|
try db.create(
|
|
index: "idx_tracks_album_order",
|
|
on: "tracks",
|
|
columns: ["albumArtist", "album", "discNumber", "trackNumber"]
|
|
)
|
|
|
|
try db.create(virtualTable: "tracks_ft", using: FTS5()) { t in
|
|
t.synchronize(withTable: "tracks")
|
|
t.tokenizer = .unicode61()
|
|
t.column("title")
|
|
t.column("artist")
|
|
t.column("albumArtist")
|
|
t.column("album")
|
|
t.column("genre")
|
|
t.column("composer")
|
|
}
|
|
}
|
|
|
|
migrator.registerMigration("v2-create-playlists") { db in
|
|
try db.create(table: "playlists") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("name", .text).notNull().unique()
|
|
t.column("createdAt", .datetime).notNull()
|
|
}
|
|
|
|
try db.create(table: "playlist_tracks") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("playlistId", .integer).notNull()
|
|
.references("playlists", onDelete: .cascade)
|
|
t.column("trackId", .integer).notNull()
|
|
.references("tracks", onDelete: .cascade)
|
|
t.column("position", .integer).notNull()
|
|
t.uniqueKey(["playlistId", "trackId"])
|
|
}
|
|
|
|
try db.create(
|
|
index: "idx_playlist_tracks_order",
|
|
on: "playlist_tracks",
|
|
columns: ["playlistId", "position"]
|
|
)
|
|
}
|
|
|
|
migrator.registerMigration("v3-create-smart-playlists") { db in
|
|
try db.create(table: "smart_playlists") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("name", .text).notNull().unique()
|
|
t.column("searchQuery", .text).notNull()
|
|
t.column("createdAt", .datetime).notNull()
|
|
}
|
|
}
|
|
|
|
try migrator.migrate(db)
|
|
}
|
|
|
|
// MARK: - Write
|
|
|
|
func insert(_ track: inout Track) throws {
|
|
try dbPool.write { db in
|
|
try track.insert(db)
|
|
}
|
|
}
|
|
|
|
func insertBatch(_ tracks: [Track]) throws {
|
|
try dbPool.write { db in
|
|
for var track in tracks {
|
|
try track.insert(db, onConflict: .ignore)
|
|
}
|
|
}
|
|
}
|
|
|
|
func updatePlayStats(trackId: Int64, playCount: Int, lastPlayedAt: Date) throws {
|
|
try dbPool.write { db in
|
|
try db.execute(
|
|
sql: "UPDATE tracks SET playCount = ?, lastPlayedAt = ? WHERE id = ?",
|
|
arguments: [playCount, lastPlayedAt, trackId]
|
|
)
|
|
}
|
|
}
|
|
|
|
func deleteTracksWithURLs(_ urls: Set<String>) throws {
|
|
try dbPool.write { db in
|
|
let placeholders = databaseQuestionMarks(count: urls.count)
|
|
try db.execute(
|
|
sql: "DELETE FROM tracks WHERE fileURL IN (\(placeholders))",
|
|
arguments: StatementArguments(Array(urls))
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: - Read
|
|
|
|
private static let validSortColumns: Set<String> = [
|
|
"title", "artist", "albumArtist", "album", "genre", "year", "duration",
|
|
"trackNumber", "dateAdded", "playCount", "rating", "bpm"
|
|
]
|
|
|
|
func fetchTracks(search: String, sortColumn: String, ascending: Bool) throws -> [Track] {
|
|
try dbPool.read { db in
|
|
try self.fetchTracks(db: db, search: search, sortColumn: sortColumn, ascending: ascending)
|
|
}
|
|
}
|
|
|
|
// Used by ValueObservation which already holds a Database access
|
|
func fetchTracks(db: Database, search: String, sortColumn: String, ascending: Bool) throws -> [Track] {
|
|
let col = Self.validSortColumns.contains(sortColumn) ? sortColumn : "title"
|
|
let order = ascending ? "ASC" : "DESC"
|
|
|
|
if search.trimmingCharacters(in: .whitespaces).isEmpty {
|
|
return try Track.fetchAll(
|
|
db,
|
|
sql: "SELECT * FROM tracks ORDER BY \(col) COLLATE NOCASE \(order)"
|
|
)
|
|
}
|
|
|
|
let terms = search.split(separator: " ").map { "\($0)*" }
|
|
let pattern = terms.joined(separator: " ")
|
|
|
|
return try Track.fetchAll(
|
|
db,
|
|
sql: """
|
|
SELECT tracks.* FROM tracks
|
|
JOIN tracks_ft ON tracks_ft.rowid = tracks.id
|
|
WHERE tracks_ft MATCH ?
|
|
ORDER BY \(col) COLLATE NOCASE \(order)
|
|
""",
|
|
arguments: [pattern]
|
|
)
|
|
}
|
|
|
|
func allFileURLs() throws -> Set<String> {
|
|
try dbPool.read { db in
|
|
let urls = try String.fetchAll(db, sql: "SELECT fileURL FROM tracks")
|
|
return Set(urls)
|
|
}
|
|
}
|
|
|
|
func trackCount() throws -> Int {
|
|
try dbPool.read { db in
|
|
try Track.fetchCount(db)
|
|
}
|
|
}
|
|
|
|
func fetchRecentlyAdded(limit: Int) throws -> [Track] {
|
|
try dbPool.read { db in
|
|
try Track.fetchAll(
|
|
db,
|
|
sql: "SELECT * FROM tracks ORDER BY dateAdded DESC LIMIT ?",
|
|
arguments: [limit]
|
|
)
|
|
}
|
|
}
|
|
|
|
func totalDuration() throws -> Double {
|
|
try dbPool.read { db in
|
|
try Double.fetchOne(db, sql: "SELECT COALESCE(SUM(duration), 0) FROM tracks") ?? 0
|
|
}
|
|
}
|
|
|
|
func fetchMonthlyAdditions(months: Int) throws -> [MonthlyCount] {
|
|
// Use a UTC calendar throughout: GRDB stores Date values as UTC ISO8601 strings,
|
|
// so SQLite's strftime('%Y-%m', …) returns UTC months. We align Swift's month
|
|
// boundaries to UTC as well to ensure consistent bucketing regardless of the
|
|
// device's local timezone.
|
|
var utcCalendar = Calendar(identifier: .gregorian)
|
|
utcCalendar.timeZone = TimeZone(identifier: "UTC")!
|
|
let now = Date()
|
|
let thisMonth = utcCalendar.dateInterval(of: .month, for: now)!.start
|
|
let startMonth = utcCalendar.date(byAdding: .month, value: -(months - 1), to: thisMonth)!
|
|
|
|
let rows: [(String, Int)] = try dbPool.read { db in
|
|
let rows = try Row.fetchAll(
|
|
db,
|
|
sql: """
|
|
SELECT strftime('%Y-%m', dateAdded) AS month, COUNT(*) AS cnt
|
|
FROM tracks
|
|
WHERE dateAdded >= ?
|
|
GROUP BY month
|
|
ORDER BY month ASC
|
|
""",
|
|
arguments: [startMonth]
|
|
)
|
|
return rows.map { ($0["month"] as String, $0["cnt"] as Int) }
|
|
}
|
|
|
|
let rowDict = Dictionary(uniqueKeysWithValues: rows)
|
|
let formatter = DateFormatter()
|
|
formatter.dateFormat = "yyyy-MM"
|
|
formatter.timeZone = TimeZone(identifier: "UTC")!
|
|
|
|
var results: [MonthlyCount] = []
|
|
for i in 0..<months {
|
|
let month = utcCalendar.date(byAdding: .month, value: i, to: startMonth)!
|
|
let key = formatter.string(from: month)
|
|
let count = rowDict[key] ?? 0
|
|
results.append(MonthlyCount(month: month, count: count))
|
|
}
|
|
return results
|
|
}
|
|
|
|
// MARK: - Playlists
|
|
|
|
func createPlaylist(name: String) throws -> Playlist {
|
|
try dbPool.write { db in
|
|
var playlist = Playlist(id: nil, name: name, createdAt: Date())
|
|
try playlist.insert(db)
|
|
return playlist
|
|
}
|
|
}
|
|
|
|
func renamePlaylist(id: Int64, name: String) throws {
|
|
try dbPool.write { db in
|
|
try db.execute(
|
|
sql: "UPDATE playlists SET name = ? WHERE id = ?",
|
|
arguments: [name, id]
|
|
)
|
|
}
|
|
}
|
|
|
|
func deletePlaylist(id: Int64) throws {
|
|
try dbPool.write { db in
|
|
try db.execute(sql: "DELETE FROM playlists WHERE id = ?", arguments: [id])
|
|
}
|
|
}
|
|
|
|
func fetchPlaylists() throws -> [Playlist] {
|
|
try dbPool.read { db in
|
|
try Playlist.fetchAll(db, sql: "SELECT * FROM playlists ORDER BY name COLLATE NOCASE ASC")
|
|
}
|
|
}
|
|
|
|
func fetchPlaylists(db: Database) throws -> [Playlist] {
|
|
try Playlist.fetchAll(db, sql: "SELECT * FROM playlists ORDER BY name COLLATE NOCASE ASC")
|
|
}
|
|
|
|
func addTrackToPlaylist(trackId: Int64, playlistId: Int64) throws {
|
|
try dbPool.write { db in
|
|
let maxPos = try Int.fetchOne(
|
|
db,
|
|
sql: "SELECT MAX(position) FROM playlist_tracks WHERE playlistId = ?",
|
|
arguments: [playlistId]
|
|
) ?? -1
|
|
var entry = PlaylistTrack(
|
|
id: nil, playlistId: playlistId, trackId: trackId, position: maxPos + 1
|
|
)
|
|
try entry.insert(db, onConflict: .ignore)
|
|
}
|
|
}
|
|
|
|
func removeTrackFromPlaylist(trackId: Int64, playlistId: Int64) throws {
|
|
try dbPool.write { db in
|
|
let position = try Int.fetchOne(
|
|
db,
|
|
sql: "SELECT position FROM playlist_tracks WHERE playlistId = ? AND trackId = ?",
|
|
arguments: [playlistId, trackId]
|
|
)
|
|
try db.execute(
|
|
sql: "DELETE FROM playlist_tracks WHERE playlistId = ? AND trackId = ?",
|
|
arguments: [playlistId, trackId]
|
|
)
|
|
if let pos = position {
|
|
try db.execute(
|
|
sql: """
|
|
UPDATE playlist_tracks SET position = position - 1
|
|
WHERE playlistId = ? AND position > ?
|
|
""",
|
|
arguments: [playlistId, pos]
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
func reorderPlaylistTrack(playlistId: Int64, fromPosition: Int, toPosition: Int) throws {
|
|
try dbPool.write { db in
|
|
let trackId = try Int64.fetchOne(
|
|
db,
|
|
sql: "SELECT trackId FROM playlist_tracks WHERE playlistId = ? AND position = ?",
|
|
arguments: [playlistId, fromPosition]
|
|
)
|
|
guard let trackId else { return }
|
|
|
|
if fromPosition < toPosition {
|
|
try db.execute(
|
|
sql: """
|
|
UPDATE playlist_tracks SET position = position - 1
|
|
WHERE playlistId = ? AND position > ? AND position <= ?
|
|
""",
|
|
arguments: [playlistId, fromPosition, toPosition]
|
|
)
|
|
} else {
|
|
try db.execute(
|
|
sql: """
|
|
UPDATE playlist_tracks SET position = position + 1
|
|
WHERE playlistId = ? AND position >= ? AND position < ?
|
|
""",
|
|
arguments: [playlistId, toPosition, fromPosition]
|
|
)
|
|
}
|
|
|
|
try db.execute(
|
|
sql: """
|
|
UPDATE playlist_tracks SET position = ?
|
|
WHERE playlistId = ? AND trackId = ?
|
|
""",
|
|
arguments: [toPosition, playlistId, trackId]
|
|
)
|
|
}
|
|
}
|
|
|
|
func fetchPlaylistTracks(playlistId: Int64, search: String = "") throws -> [Track] {
|
|
try dbPool.read { db in
|
|
try self.fetchPlaylistTracks(db: db, playlistId: playlistId, search: search)
|
|
}
|
|
}
|
|
|
|
func fetchPlaylistTracks(db: Database, playlistId: Int64, search: String = "") throws -> [Track] {
|
|
if search.trimmingCharacters(in: .whitespaces).isEmpty {
|
|
return try Track.fetchAll(
|
|
db,
|
|
sql: """
|
|
SELECT tracks.* FROM tracks
|
|
JOIN playlist_tracks ON playlist_tracks.trackId = tracks.id
|
|
WHERE playlist_tracks.playlistId = ?
|
|
ORDER BY playlist_tracks.position ASC
|
|
""",
|
|
arguments: [playlistId]
|
|
)
|
|
}
|
|
|
|
let terms = search.split(separator: " ").map { "\($0)*" }
|
|
let pattern = terms.joined(separator: " ")
|
|
|
|
return try Track.fetchAll(
|
|
db,
|
|
sql: """
|
|
SELECT tracks.* FROM tracks
|
|
JOIN playlist_tracks ON playlist_tracks.trackId = tracks.id
|
|
JOIN tracks_ft ON tracks_ft.rowid = tracks.id
|
|
WHERE playlist_tracks.playlistId = ? AND tracks_ft MATCH ?
|
|
ORDER BY playlist_tracks.position ASC
|
|
""",
|
|
arguments: [playlistId, pattern]
|
|
)
|
|
}
|
|
|
|
func playlistName(id: Int64) throws -> String? {
|
|
try dbPool.read { db in
|
|
try String.fetchOne(
|
|
db,
|
|
sql: "SELECT name FROM playlists WHERE id = ?",
|
|
arguments: [id]
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: - Smart Playlists
|
|
|
|
func createSmartPlaylist(name: String, searchQuery: String) throws -> SmartPlaylist {
|
|
try dbPool.write { db in
|
|
var smartPlaylist = SmartPlaylist(
|
|
id: nil, name: name, searchQuery: searchQuery, createdAt: Date()
|
|
)
|
|
try smartPlaylist.insert(db)
|
|
return smartPlaylist
|
|
}
|
|
}
|
|
|
|
func renameSmartPlaylist(id: Int64, name: String) throws {
|
|
try dbPool.write { db in
|
|
try db.execute(
|
|
sql: "UPDATE smart_playlists SET name = ? WHERE id = ?",
|
|
arguments: [name, id]
|
|
)
|
|
}
|
|
}
|
|
|
|
func updateSmartPlaylistQuery(id: Int64, searchQuery: String) throws {
|
|
try dbPool.write { db in
|
|
try db.execute(
|
|
sql: "UPDATE smart_playlists SET searchQuery = ? WHERE id = ?",
|
|
arguments: [searchQuery, id]
|
|
)
|
|
}
|
|
}
|
|
|
|
func deleteSmartPlaylist(id: Int64) throws {
|
|
try dbPool.write { db in
|
|
try db.execute(sql: "DELETE FROM smart_playlists WHERE id = ?", arguments: [id])
|
|
}
|
|
}
|
|
|
|
func fetchSmartPlaylists() throws -> [SmartPlaylist] {
|
|
try dbPool.read { db in
|
|
try SmartPlaylist.fetchAll(
|
|
db, sql: "SELECT * FROM smart_playlists ORDER BY name COLLATE NOCASE ASC"
|
|
)
|
|
}
|
|
}
|
|
|
|
func fetchSmartPlaylists(db: Database) throws -> [SmartPlaylist] {
|
|
try SmartPlaylist.fetchAll(
|
|
db, sql: "SELECT * FROM smart_playlists ORDER BY name COLLATE NOCASE ASC"
|
|
)
|
|
}
|
|
}
|
|
|