Rework library search to use an AST-based approach (#3554)

* Rework library search to use an AST-based approach

* Spotless apply

* Move the filtering logic to the database

* Spotless apply

* Cleanup and separation of concerns

* Add `notes` to field and general search, and chapter read, total chapters to comparison search

* Handle searching for empty fields

* Add `language` as a field-only query option

* Clean up SQL clause generations

* Spotless apply

* Do not parse `-` as a negation when followed by a separator

* Revert moving filtering logic to database

* Changelog

* Use contains for genre instead of equals

* Add special handling for source name

* Add field-only query for source id

* Apply suggestions
This commit is contained in:
NGB-Was-Taken
2026-07-22 19:05:27 +05:45
committed by GitHub
parent 628cb58862
commit e7ec672c8b
7 changed files with 429 additions and 56 deletions
@@ -0,0 +1,146 @@
package mihon.feature.library
import eu.kanade.tachiyomi.ui.library.LibraryItem
import mihon.domain.library.model.search.AndNode
import mihon.domain.library.model.search.ComparisonField
import mihon.domain.library.model.search.ComparisonQueryNode
import mihon.domain.library.model.search.EmptyQueryNode
import mihon.domain.library.model.search.FieldQueryNode
import mihon.domain.library.model.search.GeneralQueryNode
import mihon.domain.library.model.search.MangaField
import mihon.domain.library.model.search.NotNode
import mihon.domain.library.model.search.OrNode
import mihon.domain.library.model.search.QueryNode
import tachiyomi.source.local.LocalSource
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneId
import kotlin.math.abs
fun QueryNode.matches(item: LibraryItem): Boolean {
return when (this) {
is AndNode -> children.all { it.matches(item) }
is OrNode -> children.any { it.matches(item) }
is NotNode -> !child.matches(item)
is EmptyQueryNode -> true
is GeneralQueryNode -> matches(item)
is FieldQueryNode -> matches(item)
is ComparisonQueryNode -> matches(item)
}
}
private fun GeneralQueryNode.matches(item: LibraryItem): Boolean {
val manga = item.libraryManga.manga
// Use when so each added field has to be handled explicitly
val match = MangaField.entries.any { field ->
if (field.fieldOnly) return@any false
when (field) {
MangaField.TITLE -> manga.title.contains(value, ignoreCase = true)
MangaField.AUTHOR -> manga.author?.contains(value, ignoreCase = true) ?: false
MangaField.ARTIST -> manga.artist?.contains(value, ignoreCase = true) ?: false
MangaField.DESCRIPTION -> manga.description?.contains(value, ignoreCase = true) ?: false
MangaField.GENRE -> manga.genre?.any { it.contains(value, ignoreCase = true) } ?: false
MangaField.SOURCE -> {
item.sourceName.contains(value, ignoreCase = true) ||
(value.equals("local", ignoreCase = true) && manga.source == LocalSource.ID)
}
MangaField.NOTES -> manga.notes.contains(value, ignoreCase = true)
// field-only queries; unreachable; added here to make `when` exhaustive
MangaField.LANGUAGE, MangaField.SOURCE_ID -> error("How did we get here?")
}
}
return if (negated) !match else match
}
private fun FieldQueryNode.matches(item: LibraryItem): Boolean {
val manga = item.libraryManga.manga
val match = when (field) {
MangaField.GENRE -> {
if (value.isEmpty()) {
manga.genre.isNullOrEmpty()
} else {
manga.genre?.any { it.contains(value, ignoreCase = true) } ?: false
}
}
MangaField.SOURCE -> {
if (value.isEmpty()) {
item.sourceName.isEmpty()
} else {
item.sourceName.contains(value, ignoreCase = true) ||
(value.equals("local", ignoreCase = true) && manga.source == LocalSource.ID)
}
}
MangaField.SOURCE_ID -> {
value.toLongOrNull()?.let { it == manga.source } ?: false
}
else -> {
val text = when (field) {
MangaField.TITLE -> manga.title
MangaField.AUTHOR -> manga.author
MangaField.ARTIST -> manga.artist
MangaField.DESCRIPTION -> manga.description
MangaField.NOTES -> manga.notes
MangaField.LANGUAGE -> item.sourceLanguage
// unreachable; added here to make `when` exhaustive
MangaField.GENRE, MangaField.SOURCE, MangaField.SOURCE_ID -> error("How did we get here?")
}
if (value.isEmpty()) {
text.isNullOrEmpty()
} else {
text?.contains(value, ignoreCase = true) ?: false
}
}
}
return if (negated) !match else match
}
private fun ComparisonQueryNode.matches(item: LibraryItem): Boolean {
val manga = item.libraryManga.manga
fun compareDates(timestamp: Long, value: String): Boolean? {
val inputDate = runCatching { LocalDate.parse(value) }.getOrNull() ?: return null
val mangaDate = Instant.ofEpochMilli(timestamp).atZone(ZoneId.systemDefault()).toLocalDate()
return queryComparator.apply(mangaDate, inputDate)
}
val match = when (field) {
ComparisonField.ID -> value.toLongOrNull()?.let { queryComparator.apply(manga.id, it) }
ComparisonField.DATE_ADDED -> compareDates(manga.dateAdded, value)
ComparisonField.FETCH_INTERVAL -> value.toIntOrNull()
?.let { queryComparator.apply(abs(manga.fetchInterval), it) }
ComparisonField.NEXT_UPDATE -> compareDates(manga.nextUpdate, value)
ComparisonField.UNREAD -> {
value.toLongOrNull()?.let {
queryComparator.apply(item.unreadCount, it)
}
}
ComparisonField.READ -> {
value.toLongOrNull()?.let {
queryComparator.apply(item.libraryManga.readCount, it)
}
}
ComparisonField.TOTAL -> {
value.toLongOrNull()?.let {
queryComparator.apply(item.libraryManga.totalChapters, it)
}
}
} ?: false
return if (negated) !match else match
}