diff --git a/beets/dbcore/query.py b/beets/dbcore/query.py index 1ff56f101..c7ca44452 100644 --- a/beets/dbcore/query.py +++ b/beets/dbcore/query.py @@ -508,50 +508,6 @@ class CollectionQuery(Query): return reduce(mul, map(hash, self.subqueries), 1) -class AnyFieldQuery(CollectionQuery): - """A query that matches if a given FieldQuery subclass matches in - any field. The individual field query class is provided to the - constructor. - """ - - @property - def field_names(self) -> set[str]: - """Return a set with field names that this query operates on.""" - return set(self.fields) - - def __init__(self, pattern, fields, cls: FieldQueryType): - self.pattern = pattern - self.fields = fields - self.query_class = cls - - subqueries = [] - for field in self.fields: - subqueries.append(cls(field, pattern, True)) - # TYPING ERROR - super().__init__(subqueries) - - def clause(self) -> tuple[str | None, Sequence[SQLiteType]]: - return self.clause_with_joiner("or") - - def match(self, obj: Model) -> bool: - for subq in self.subqueries: - if subq.match(obj): - return True - return False - - def __repr__(self) -> str: - return ( - f"{self.__class__.__name__}({self.pattern!r}, {self.fields!r}, " - f"{self.query_class.__name__})" - ) - - def __eq__(self, other) -> bool: - return super().__eq__(other) and self.query_class == other.query_class - - def __hash__(self) -> int: - return hash((self.pattern, tuple(self.fields), self.query_class)) - - class MutableCollectionQuery(CollectionQuery): """A collection query whose subqueries may be modified after the query is initialized. diff --git a/beets/dbcore/queryparse.py b/beets/dbcore/queryparse.py index c4ad9c4c9..f84ed7436 100644 --- a/beets/dbcore/queryparse.py +++ b/beets/dbcore/queryparse.py @@ -149,19 +149,13 @@ def construct_query_part( query_part, query_classes, prefixes ) - # If there's no key (field name) specified, this is a "match - # anything" query. if key is None: - # The query type matches a specific field, but none was - # specified. So we use a version of the query that matches - # any field. - out_query = query.AnyFieldQuery( - pattern, model_cls._search_fields, query_class - ) - - # Field queries get constructed according to the name of the field - # they are querying. + # If there's no key (field name) specified, this is a "match anything" + # query. + out_query = model_cls.any_field_query(pattern, query_class) else: + # Field queries get constructed according to the name of the field + # they are querying. out_query = model_cls.field_query(key.lower(), pattern, query_class) # Apply negation. diff --git a/beets/library.py b/beets/library.py index 46c1e43aa..a05052427 100644 --- a/beets/library.py +++ b/beets/library.py @@ -395,6 +395,12 @@ class LibModel(dbcore.Model["Library"]): return query_cls(field, pattern, fast) + @classmethod + def any_field_query(cls, *args, **kwargs) -> dbcore.OrQuery: + return dbcore.OrQuery( + [cls.field_query(f, *args, **kwargs) for f in cls._search_fields] + ) + def duplicates_query(self, fields: list[str]) -> dbcore.AndQuery: """Return a query for entities with same values in the given fields.""" return dbcore.AndQuery( diff --git a/docs/changelog.rst b/docs/changelog.rst index 186749d46..f38a40a29 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -38,6 +38,9 @@ Bug fixes: request their own last.fm genre. Also log messages regarding what's been tagged are now more polished. :bug:`5582` +* Fix ambiguous column name ``sqlite3.OperationalError`` that occured in album + queries that filtered album track titles, for example ``beet list -a keyword + title:foo``. For packagers: diff --git a/test/test_dbcore.py b/test/test_dbcore.py index 03fe02d19..2ff20c3a3 100644 --- a/test/test_dbcore.py +++ b/test/test_dbcore.py @@ -588,7 +588,7 @@ class QueryFromStringsTest(unittest.TestCase): q = self.qfs(["foo", "bar:baz"]) assert isinstance(q, dbcore.query.AndQuery) assert len(q.subqueries) == 2 - assert isinstance(q.subqueries[0], dbcore.query.AnyFieldQuery) + assert isinstance(q.subqueries[0], dbcore.query.OrQuery) assert isinstance(q.subqueries[1], dbcore.query.SubstringQuery) def test_parse_fixed_type_query(self): diff --git a/test/test_query.py b/test/test_query.py index 6f7fe4da7..f85e5c637 100644 --- a/test/test_query.py +++ b/test/test_query.py @@ -56,40 +56,6 @@ class AssertsMixin: assert item.id not in result_ids -class AnyFieldQueryTest(ItemInDBTestCase): - def test_no_restriction(self): - q = dbcore.query.AnyFieldQuery( - "title", - beets.library.Item._fields.keys(), - dbcore.query.SubstringQuery, - ) - assert self.lib.items(q).get().title == "the title" - - def test_restriction_completeness(self): - q = dbcore.query.AnyFieldQuery( - "title", ["title"], dbcore.query.SubstringQuery - ) - assert self.lib.items(q).get().title == "the title" - - def test_restriction_soundness(self): - q = dbcore.query.AnyFieldQuery( - "title", ["artist"], dbcore.query.SubstringQuery - ) - assert self.lib.items(q).get() is None - - def test_eq(self): - q1 = dbcore.query.AnyFieldQuery( - "foo", ["bar"], dbcore.query.SubstringQuery - ) - q2 = dbcore.query.AnyFieldQuery( - "foo", ["bar"], dbcore.query.SubstringQuery - ) - assert q1 == q2 - - q2.query_class = None - assert q1 != q2 - - # A test case class providing a library with some dummy data and some # assertions involving that data. class DummyDataTestCase(BeetsTestCase, AssertsMixin): @@ -954,14 +920,6 @@ class NotQueryTest(DummyDataTestCase): self.assert_items_matched(not_results, ["foo bar", "beets 4 eva"]) self.assertNegationProperties(q) - def test_type_anyfield(self): - q = dbcore.query.AnyFieldQuery( - "foo", ["title", "artist", "album"], dbcore.query.SubstringQuery - ) - not_results = self.lib.items(dbcore.query.NotQuery(q)) - self.assert_items_matched(not_results, ["baz qux"]) - self.assertNegationProperties(q) - def test_type_boolean(self): q = dbcore.query.BooleanQuery("comp", True) not_results = self.lib.items(dbcore.query.NotQuery(q)) @@ -1135,7 +1093,14 @@ class RelatedQueriesTest(BeetsTestCase, AssertsMixin): results = self.lib.items(q) self.assert_items_matched(results, ["Album1 Item1", "Album1 Item2"]) - def test_filter_by_common_field(self): - q = "catalognum:ABC Album1" + def test_filter_albums_by_common_field(self): + # title:Album1 ensures that the items table is joined for the query + q = "title:Album1 Album1" results = self.lib.albums(q) self.assert_albums_matched(results, ["Album1"]) + + def test_filter_items_by_common_field(self): + # artpath::A ensures that the albums table is joined for the query + q = "artpath::A Album1" + results = self.lib.items(q) + self.assert_items_matched(results, ["Album1 Item1", "Album1 Item2"])