--wip-- [skip ci]

odmantic/field.py

@@ -3,6 +3,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    List,
     Optional,
     Pattern,
     Sequence,
@@ -202,7 +203,19 @@ class ODMField(ODMBaseField):
 
     __slots__ = ("primary_field",)
     __allowed_operators__ = set(
-        ("eq", "ne", "in_", "not_in", "lt", "lte", "gt", "gte", "match", "asc", "desc")
+        (
+            "eq",
+            "ne",
+            "in_",
+            "not_in",
+            "lt",
+            "lte",
+            "gt",
+            "gte",
+            "match",
+            "asc",
+            "desc",
+        )
     )
 
     def __init__(
@@ -302,6 +315,16 @@ def __getattribute__(self, name: str) -> Any:
                         f"attribute {name} not found in {field.model.__name__}"
                     )
             return FieldProxy(parent=self, field=child_field)
+        elif isinstance(field, ODMField) and name == "any":
+            if name == "any":
+                return FieldProxy(
+                    parent=self,
+                    field=ODMField(
+                        primary_field=False,
+                        key_name="$any",
+                        model_config=field.model_config,
+                    ),
+                )
 
         if name not in field.__allowed_operators__:
             raise AttributeError(

odmantic/query.py

@@ -119,6 +119,27 @@ def match(field: FieldProxyAny, pattern: Union[Pattern, str]) -> QueryExpression
     return QueryExpression({+field: r})
 
 
+def contain(field: FieldProxyAny, expected_content: Sequence[Any]) -> QueryExpression:
+    """Select the instances where `field` contains elements in `expected_content`.
+
+    !!! warning
+        The order of the elements is not taken into account and this will only check
+        that the `expected_content` are included in the actual content of the field. To
+        have stricter conditions, it's possible to use `eq`(==) directly.
+    """
+    return _cmp_expression(field, "$all", expected_content)
+
+
+def size(field: FieldProxyAny, length: int) -> QueryExpression:
+    """Select the instances where `field` is an array of size `length`."""
+    return _cmp_expression(field, "$size", length)
+
+
+def any_(field: FieldProxyAny, expression: QueryDictBool) -> Any:
+    """Select instances where an element of `field` matches the `expression`."""
+    return _cmp_expression(field, "$elemMatch", expression)
+
+
 class SortExpression(Dict[str, Literal[-1, 1]]):
     """Base object used to build sort queries."""
 

tests/unit/test_query.py

@@ -1,4 +1,7 @@
-from odmantic.query import QueryExpression, SortExpression, asc
+from typing import List
+
+from odmantic.model import Model
+from odmantic.query import QueryExpression, SortExpression, any_, asc, eq, gte
 from tests.zoo.book_embedded import Book, Publisher
 from tests.zoo.tree import TreeKind, TreeModel
 
@@ -38,3 +41,36 @@ def test_sort_repr():
 
 def test_sort_empty_repr():
     assert repr(SortExpression()) == "SortExpression()"
+
+
+class ModelWithIntArray(Model):
+    array: List[int]
+
+
+def test_array_any_eq():
+    expected = {"array": {"$elemMatch": {"$eq": 42}}}
+    assert any_(ModelWithIntArray.array, {"$eq": 42}) == expected
+    assert eq(any_(ModelWithIntArray.array), 42) == expected
+    # assert ModelWithIntArray.array.any().eq(42) == expected
+    # assert (ModelWithIntArray.array.any() == 42) == expected
+
+
+def test_array_any_gte():
+    expected = {"array": {"$elemMatch": {"$gte": 42}}}
+    assert any_(ModelWithIntArray.array, {"$gte": 42}) == expected
+    # assert ModelWithIntArray.array.any().gte(42) == expected
+    # assert (ModelWithIntArray.array.any() >= 42) == expected
+
+
+# def test_array_all_eq():
+#     expected = {"array": {"$all": {"$eq": 42}}}
+#     assert eq(ModelWithIntArray.array.all(), 42) == expected
+#     assert ModelWithIntArray.array.all().eq(42) == expected
+#     assert (ModelWithIntArray.array.all() == 42) == expected
+
+
+# def test_array_all_gte():
+#     expected = {"array": {"$all": {"$gte": 42}}}
+#     assert ModelWithIntArray.array.all().gte(42) == expected
+#     assert gte(ModelWithIntArray.array.all(), 42) == expected
+#     assert (ModelWithIntArray.array.all() >= 42) == expected