Source file queryArtist.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
(*****************************************************************************)
(*                                                                           *)
(*  Copyright (C) 2026 Yves Ndiaye                                           *)
(*                                                                           *)
(* This Source Code Form is subject to the terms of the Mozilla Public       *)
(* License, v. 2.0. If a copy of the MPL was not distributed with this       *)
(* file, You can obtain one at https://mozilla.org/MPL/2.0/.                 *)
(*                                                                           *)
(*****************************************************************************)

include QueryUtil

let matches_node _subfields (artist, albums, stats) node =
  let id = SkhcDb.Artist.id artist in
  let name = SkhcDb.Artist.name artist in
  let sort_name = SkhcDb.Artist.sort_name artist in
  let flag = SkhcDb.Artist.flag artist in
  let artwork = SkhcDb.Artist.artwork artist in
  let rating = SkhcDb.Artist.rating artist in
  let music_count = SkhcDb.Artist.Stats.music_count stats in
  let album_count = SkhcDb.Artist.Stats.album_count stats in
  let play_count = SkhcDb.Artist.Stats.play_count stats in
  let avg_duration = SkhcDb.Artist.Stats.avg_duration stats in
  let avg_rating = SkhcDb.Artist.Stats.avg_rating stats in
  let avg_size = SkhcDb.Artist.Stats.avg_size stats in
  let duration = SkhcDb.Artist.Stats.duration stats in
  let played_at = SkhcDb.Artist.Stats.played_at stats in
  let created_at = SkhcDb.Artist.created_at artist in
  let modified_at = SkhcDb.Artist.updated_at artist in
  match node with
  | Node.Substring s ->
      let insensible = true in
      let regex = false in
      matches ~insensible regex s name || omatches ~insensible regex s sort_name
  | Field (FString s) -> (
      let regex = Field.String.regex s in
      let insensible = Field.String.insensible s in
      let field = Field.String.key s in
      let value = Field.String.value s in
      match field with
      | SortName ->
          omatches ~insensible regex value sort_name
      | Title ->
          matches ~insensible regex value name
      | Artist ->
          matches ~insensible regex value name
      | Path ->
          matches ~insensible regex value name
      | AlbumArtist ->
          matches ~insensible regex value name
      | Composer ->
          matches ~insensible regex value name
      | Album ->
          SkhcDb.Ids.Map.exists
            (fun _ album_name -> matches ~insensible regex value album_name)
            albums
      | Genre ->
          false
      | Arbitrary _ ->
          false
      | FileExtension ->
          false
    )
  | Field (FBool b) -> (
      let field = Field.Bool.key b in
      let b = Field.Bool.value b in
      match field with
      | Flag ->
          flag = b
      | Art ->
          let cover = Option.is_some artwork in
          b = cover
    )
  | Field (FInt64 i64) -> (
      let field = Field.Int64.key i64 in
      let frange = Field.Int64.value i64 in
      match field with Id -> Range.matches frange id | Size -> false
    )
  | Field (FInt i) -> (
      let field = Field.Int.key i in
      let frange = Field.Int.value i in
      match field with
      | Rating ->
          rating
          |> Option.map (Range.matches frange)
          |> Option.value ~default:false
      | AlbumCount ->
          Range.matches frange album_count
      | Length ->
          Range.matches frange duration
      | Plays ->
          Range.matches frange play_count
      | MusicCount ->
          Range.matches frange music_count
      | Track | Year | Disc ->
          false
    )
  | Field (FFloat f) -> (
      let field = Field.Float.key f in
      let frange = Field.Float.value f in
      match field with
      | AvgDuration ->
          Range.matches frange avg_duration
      | AvgRating ->
          Range.matches frange avg_rating
      | AvgSize ->
          Range.matches frange avg_size
      | CreatedAt ->
          Range.matches frange created_at
      | ModifiedAt ->
          Range.matches frange modified_at
      | PlayedAt ->
          played_at
          |> Option.map (Range.matches frange)
          |> Option.value ~default:false
    )

let compare_key (r, key) lhs rhs =
  let lhs, rhs =
    if r then
      (rhs, lhs)
    else
      (lhs, rhs)
  in
  let lhs, _lalbum, lstats = lhs in
  let rhs, _ralbum, rstats = rhs in
  let cmp c f lhs rhs = c (f lhs) (f rhs) in
  let ocmp c f lhs rhs = Option.compare c (f lhs) (f rhs) in
  match key with
  | Field.(FString s) -> (
      let field = Field.String.key s in
      match field with
      | SortName ->
          ocmp String.compare SkhcDb.Artist.sort_name lhs rhs
      | Title | Artist | Path | AlbumArtist | Composer ->
          cmp String.compare SkhcDb.Artist.name lhs rhs
      | Album ->
          0
      | Genre ->
          0
      | Arbitrary _ ->
          0
      | FileExtension ->
          0
    )
  | FBool b -> (
      let field = Field.Bool.key b in
      match field with
      | Flag ->
          cmp Bool.compare SkhcDb.Artist.flag lhs rhs
      | Art ->
          cmp Bool.compare
            (fun s -> Option.is_some @@ SkhcDb.Artist.artwork s)
            lhs rhs
    )
  | FInt64 i64 -> (
      let field = Field.Int64.key i64 in
      match field with
      | Id ->
          cmp Int64.unsigned_compare SkhcDb.Artist.id lhs rhs
      | Size ->
          cmp Int64.unsigned_compare SkhcDb.Artist.Stats.size lstats rstats
    )
  | FInt i -> (
      let field = Field.Int.key i in
      match field with
      | Rating ->
          ocmp Int.compare SkhcDb.Artist.rating lhs rhs
      | Plays ->
          cmp Int.compare SkhcDb.Artist.Stats.play_count lstats rstats
      | AlbumCount ->
          cmp Int.compare SkhcDb.Artist.Stats.album_count lstats rstats
      | MusicCount ->
          cmp Int.compare SkhcDb.Artist.Stats.music_count lstats rstats
      | Length ->
          cmp Int.compare SkhcDb.Artist.Stats.duration lstats rstats
      | Track | Year | Disc ->
          0
    )
  | FFloat f -> (
      let field = Field.Float.key f in
      match field with
      | AvgDuration ->
          cmp Float.compare SkhcDb.Artist.Stats.avg_duration lstats rstats
      | AvgRating ->
          cmp Float.compare SkhcDb.Artist.Stats.avg_rating lstats rstats
      | AvgSize ->
          cmp Float.compare SkhcDb.Artist.Stats.avg_size lstats rstats
      | CreatedAt ->
          cmp Float.compare SkhcDb.Artist.created_at lhs rhs
      | ModifiedAt ->
          cmp Float.compare SkhcDb.Artist.updated_at lhs rhs
      | PlayedAt ->
          ocmp Float.compare SkhcDb.Artist.Stats.played_at lstats rstats
    )