@@ -20,5 +20,9 @@ Added
   attributes a mapping stores.
 - Filters, sorts and uniqueness checks compare strings with the comparison key of the policy of
   the provider: exactly on SQLite, and approximately on PostgreSQL.
+- A column of type :class:`~sqlalchemy.types.Enum` holds the string it stores: the name of the
+  member, or its value with ``values_callable``. Filters and sorts compare this string, also on
+  the native enumerations of PostgreSQL. A string outside the enumeration is refused with
+  ``invalidValue``.
 - A search or a read does not load the collections that ``attributes`` and ``excludedAttributes``
   remove from the response, such as the members of the groups.
@@ -6,6 +6,7 @@
 from typing import Any
 
 from pydantic import BaseModel
+from scim2_models import AttributeBinding
 from scim2_models import InvalidValueException
 from scim2_models import Meta
 from scim2_models import Mutability
@@ -42,6 +43,8 @@ def _read(column: _Column, record: Any) -> Any:
     value = getattr(record, column.key)
     if value is None or not column.readable:
         return None
+    if isinstance(value, Enum) and column.enumeration is not None:
+        return column.stored_string(column.enumeration, value)
     return _as_scim(value)
 
 
@@ -233,6 +236,7 @@ def _check_storable(
         if stored is not None:
             current = _comparable(Path(binding.urn).get(stored, strict=False))
         if storage == _Storage.written:
+            _check_enumerated(mapping, binding, value)
             if (
                 value is None
                 and current is not None
@@ -256,6 +260,21 @@ def _check_storable(
         )
 
 
+def _check_enumerated(
+    mapping: ResourceMapping, binding: AttributeBinding, value: Any
+) -> None:
+    """Refuse a string that an Enum column does not store, rather than failing in the database."""
+    _, column = mapping._lookup(binding)
+    if column is None or column.enumeration is None:
+        return
+    stored = column.enumeration.enums
+    for item in value if isinstance(value, list) else [value]:
+        if item is not None and item not in stored:
+            raise InvalidValueException(
+                detail=f"'{binding.urn}' cannot hold {item!r} on this server"
+            )
+
+
 def _comparable(value: Any) -> Any:
     """Return a value in a form two resources compare in.
 
 
@@ -17,6 +17,7 @@
 from scim2_models import Schema
 from scim2_models import Uniqueness
 from sqlalchemy import ColumnElement
+from sqlalchemy import Enum as SqlEnum
 from sqlalchemy import String
 from sqlalchemy import cast
 from sqlalchemy import inspect
@@ -152,13 +153,32 @@ def nullable(self) -> bool:
         columns = getattr(getattr(self.expression, "property", None), "columns", None)
         return columns is None or bool(columns[0].nullable)
 
+    @property
+    def enumeration(self) -> SqlEnum | None:
+        """The type of the column when it is an Enum, which stores strings."""
+        sql_type = self.expression.type
+        return sql_type if isinstance(sql_type, SqlEnum) else None
+
     @property
     def compared(self) -> ColumnElement[Any]:
-        """The expression filters compare."""
-        if self.textual:
+        """The expression filters and sorts compare.
+
+        An Enum column is compared as text. PostgreSQL applies no string
+        function to its native enumerations, and sorts them in the order of
+        their declaration.
+        """
+        if self.textual or self.enumeration is not None:
             return cast(self.expression, String)
         return self.expression
 
+    @staticmethod
+    def stored_string(enumeration: SqlEnum, member: Enum) -> str:
+        """Return the string an Enum column stores for a member: its name, or its value with values_callable."""
+        strings: dict[Enum, str] = dict(
+            zip(type(member), enumeration.enums, strict=False)
+        )
+        return strings[member]
+
 
 @dataclass(eq=False)
 class _Collection:
 
@@ -183,7 +183,7 @@ def visit_value_path(self, node: ValuePath) -> ColumnElement[bool]:
 
 def _present(column: _Column) -> ColumnElement[bool]:
     """Per RFC 7644 §3.4.2.2, an empty string is no value."""
-    expression = column.expression
+    expression = column.compared
     if column.is_string:
         return and_(expression.is_not(None), expression != "")
     return expression.is_not(None)
 
@@ -0,0 +1,181 @@
+import datetime
+import enum
+import uuid
+
+import pytest
+from scim2_models import InvalidValueException
+from scim2_models import SearchRequest
+from scim2_models import User
+from sqlalchemy import Enum
+from sqlalchemy import ForeignKey
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import Mapped
+from sqlalchemy.orm import mapped_column
+from sqlalchemy.orm import relationship
+
+from scim2_sqlalchemy import Many
+from scim2_sqlalchemy import ResourceMapping
+
+
+class Color(enum.Enum):
+    Red = "Rouge"
+    blue = "bleu"
+    Green = "Vert"
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class ColoredUser(Base):
+    """A user whose title column stores the names of the members, and whose external identifier stores their values."""
+
+    __tablename__ = "colored_users"
+
+    id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
+    user_name: Mapped[str] = mapped_column(unique=True)
+    title: Mapped[Color | None] = mapped_column(Enum(Color, name="title_color"))
+    external_id: Mapped[Color | None] = mapped_column(
+        Enum(
+            Color,
+            name="external_color",
+            values_callable=lambda members: [member.value for member in members],
+        )
+    )
+    created: Mapped[datetime.datetime]
+    last_modified: Mapped[datetime.datetime]
+    version: Mapped[int] = mapped_column()
+
+    emails: Mapped[list["ColoredEmail"]] = relationship(
+        cascade="all, delete-orphan", order_by="ColoredEmail.id"
+    )
+
+    __mapper_args__ = {"version_id_col": version}
+
+
+class ColoredEmail(Base):
+    __tablename__ = "colored_emails"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("colored_users.id"))
+    value: Mapped[str]
+    type: Mapped[Color | None] = mapped_column(Enum(Color, name="email_color"))
+
+
+COLORED_USERS = ResourceMapping(
+    User,
+    ColoredUser,
+    {
+        "id": ColoredUser.id,
+        "userName": ColoredUser.user_name,
+        "title": ColoredUser.title,
+        "externalId": ColoredUser.external_id,
+        "emails": Many(
+            ColoredUser.emails,
+            {"value": ColoredEmail.value, "type": ColoredEmail.type},
+        ),
+        "meta.created": ColoredUser.created,
+        "meta.lastModified": ColoredUser.last_modified,
+    },
+    version=ColoredUser.version,
+)
+
+
+@pytest.fixture
+def storage(database_url, storage_factory, user_type):
+    """Return a storage of users with enumerated columns: a with Red, b with blue, c with Green, d without."""
+    engine = create_engine(database_url)
+    Base.metadata.drop_all(engine)
+    Base.metadata.create_all(engine)
+    engine.dispose()
+    storage = storage_factory(mappings={"User": COLORED_USERS})
+    for user_name, title, external_id in [
+        ("a", "Red", "Rouge"),
+        ("b", "blue", "bleu"),
+        ("c", "Green", "Vert"),
+        ("d", None, None),
+    ]:
+        emails = [{"value": f"{user_name}@example.org", "type": title}]
+        storage.create(
+            user_type,
+            User(
+                user_name=user_name,
+                title=title,
+                external_id=external_id,
+                emails=emails,
+            ),
+        )
+    return storage
+
+
+def user_names(storage, user_type, **parameters):
+    _, resources = storage.search([user_type], SearchRequest(**parameters))
+    return [resource.user_name for resource in resources]
+
+
+def test_an_enumerated_column_reads_back_the_string_it_stores(storage, user_type):
+    """A resource holds the string the column stores: the name of the member, or its value with values_callable."""
+    _, (user,) = storage.search([user_type], SearchRequest(filter='userName eq "a"'))
+
+    assert user.title == "Red"
+    assert user.external_id == "Rouge"
+    assert user.emails[0].type == "Red"
+
+
+@pytest.mark.parametrize(
+    ("scim_filter", "expected"),
+    [
+        ('title eq "blue"', ["b"]),
+        ('title eq "BLUE"', ["b"]),
+        ('title eq "bleu"', []),
+        ('title gt "h"', ["a"]),
+        ('title co "e"', ["a", "b", "c"]),
+        ("title pr", ["a", "b", "c"]),
+        ('externalId eq "bleu"', ["b"]),
+        ('externalId eq "Bleu"', []),
+        ('externalId gt "S"', ["b", "c"]),
+        ('emails[type eq "green"]', ["c"]),
+        ("emails.type pr", ["a", "b", "c"]),
+    ],
+)
+def test_an_enumerated_column_is_filtered_on_the_string_it_stores(
+    storage, user_type, scim_filter, expected
+):
+    """A filter compares the string the resource holds, as for any string column."""
+    assert sorted(user_names(storage, user_type, filter=scim_filter)) == expected
+
+
+@pytest.mark.parametrize(
+    ("sort_by", "sort_order", "expected"),
+    [
+        ("title", "ascending", ["b", "c", "a", "d"]),
+        ("title", "descending", ["d", "a", "c", "b"]),
+        ("externalId", "ascending", ["a", "c", "b", "d"]),
+    ],
+)
+def test_an_enumerated_column_sorts_on_the_string_it_stores(
+    storage, user_type, sort_by, sort_order, expected
+):
+    """The order is the one of the strings, and not the order the members are declared in."""
+    assert (
+        user_names(storage, user_type, sort_by=sort_by, sort_order=sort_order)
+        == expected
+    )
+
+
+@pytest.mark.parametrize(
+    "user",
+    [
+        User(user_name="e", title="Purple"),
+        User(user_name="e", title="Rouge"),
+        User(user_name="e", external_id="Red"),
+        User(user_name="e", emails=[{"value": "e@example.org", "type": "Purple"}]),
+    ],
+)
+def test_an_enumerated_column_refuses_a_string_it_does_not_store(
+    storage, user_type, user
+):
+    """A string outside the enumeration is refused with a 400, rather than failing in the database."""
+    with pytest.raises(InvalidValueException):
+        storage.create(user_type, user)