Use table-qualified names in any field query

In order to include the table name for fields in this query, use the
`field_query` method.

Since `AnyFieldQuery` is just an `OrQuery` under the hood, remove it and
construct `OrQuery` explicitly instead.

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.

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.

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(

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:
 

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):

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"])